bundis 0.1.0

package/src/sidecar/pubsub.ts

@@ -0,0 +1,162 @@
+/**
+ * PubSubHub — single-process in-memory pub/sub (§6.2).
+ *
+ * Maps channels and glob patterns to the set of subscribed connections. PUBLISH
+ * pushes RESP3 push frames (`>`) directly to each matching connection's socket.
+ * Multi-process broadcast is explicitly a non-goal.
+ */
+
+import { R, type Reply } from "../resp/types";
+import type { Connection } from "../connection";
+
+export class PubSubHub {
+  #channels = new Map<string, Set<Connection>>();
+  #patterns = new Map<string, Set<Connection>>();
+
+  subscribe(conn: Connection, channel: string): number {
+    addTo(this.#channels, channel, conn);
+    conn.channels.add(channel);
+    return conn.subscriptionCount();
+  }
+
+  unsubscribe(conn: Connection, channel: string): number {
+    removeFrom(this.#channels, channel, conn);
+    conn.channels.delete(channel);
+    return conn.subscriptionCount();
+  }
+
+  psubscribe(conn: Connection, pattern: string): number {
+    addTo(this.#patterns, pattern, conn);
+    conn.patterns.add(pattern);
+    return conn.subscriptionCount();
+  }
+
+  punsubscribe(conn: Connection, pattern: string): number {
+    removeFrom(this.#patterns, pattern, conn);
+    conn.patterns.delete(pattern);
+    return conn.subscriptionCount();
+  }
+
+  /** Drop a connection from all channels/patterns (on disconnect). */
+  drop(conn: Connection): void {
+    for (const ch of conn.channels) removeFrom(this.#channels, ch, conn);
+    for (const p of conn.patterns) removeFrom(this.#patterns, p, conn);
+    conn.channels.clear();
+    conn.patterns.clear();
+  }
+
+  /** Deliver a message; returns the number of clients that received it. */
+  publish(channel: string, message: Uint8Array): number {
+    let n = 0;
+    const direct = this.#channels.get(channel);
+    if (direct) {
+      const frame = R.push([R.bulk("message"), R.bulk(channel), R.bulk(message)]);
+      for (const conn of direct) {
+        conn.send(frame);
+        n++;
+      }
+    }
+    for (const [pattern, conns] of this.#patterns) {
+      if (!matchPattern(pattern, channel)) continue;
+      const frame = R.push([
+        R.bulk("pmessage"),
+        R.bulk(pattern),
+        R.bulk(channel),
+        R.bulk(message),
+      ]);
+      for (const conn of conns) {
+        conn.send(frame);
+        n++;
+      }
+    }
+    return n;
+  }
+
+  channelNames(): string[] {
+    return [...this.#channels.entries()].filter(([, s]) => s.size > 0).map(([c]) => c);
+  }
+
+  numSub(channel: string): number {
+    return this.#channels.get(channel)?.size ?? 0;
+  }
+}
+
+function addTo(map: Map<string, Set<Connection>>, key: string, conn: Connection): void {
+  let s = map.get(key);
+  if (!s) {
+    s = new Set();
+    map.set(key, s);
+  }
+  s.add(conn);
+}
+
+function removeFrom(
+  map: Map<string, Set<Connection>>,
+  key: string,
+  conn: Connection,
+): void {
+  const s = map.get(key);
+  if (!s) return;
+  s.delete(conn);
+  if (s.size === 0) map.delete(key);
+}
+
+/** Redis-style glob match: `*` `?` `[...]` with `\` escapes. */
+export function matchPattern(pattern: string, str: string): boolean {
+  return globMatch(pattern, 0, str, 0);
+}
+
+function globMatch(p: string, pi: number, s: string, si: number): boolean {
+  while (pi < p.length) {
+    const pc = p[pi]!;
+    if (pc === "*") {
+      while (pi + 1 < p.length && p[pi + 1] === "*") pi++;
+      if (pi + 1 === p.length) return true;
+      for (let k = si; k <= s.length; k++) {
+        if (globMatch(p, pi + 1, s, k)) return true;
+      }
+      return false;
+    }
+    if (si >= s.length) return false;
+    if (pc === "?") {
+      pi++;
+      si++;
+      continue;
+    }
+    if (pc === "[") {
+      const close = p.indexOf("]", pi + 1);
+      if (close === -1) {
+        if (p[pi] !== s[si]) return false; // literal '['
+        pi++;
+        si++;
+        continue;
+      }
+      let negate = false;
+      let start = pi + 1;
+      if (p[start] === "^") {
+        negate = true;
+        start++;
+      }
+      let matched = false;
+      for (let k = start; k < close; k++) {
+        if (p[k + 1] === "-" && k + 2 < close) {
+          if (s[si]! >= p[k]! && s[si]! <= p[k + 2]!) matched = true;
+          k += 2;
+        } else if (p[k] === s[si]) {
+          matched = true;
+        }
+      }
+      if (matched === negate) return false;
+      pi = close + 1;
+      si++;
+      continue;
+    }
+    if (pc === "\\" && pi + 1 < p.length) pi++;
+    if (p[pi] !== s[si]) return false;
+    pi++;
+    si++;
+  }
+  return si === s.length;
+}
+
+export type { Reply };

package/src/sidecar/reaper.ts

@@ -0,0 +1,34 @@
+/**
+ * ExpiryReaper — active TTL sweep (§5.3.2).
+ *
+ * Lazy expiry (on read) keeps expired keys from leaking into replies, but does
+ * not reclaim keys that are never touched. This periodic sweep deletes expired
+ * rows in bulk so DBSIZE and on-disk size stay consistent.
+ */
+
+import type { StorageEngine } from "../storage/types";
+
+export class ExpiryReaper {
+  #timer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(
+    private readonly storage: StorageEngine,
+    private readonly intervalMs: number,
+  ) {}
+
+  start(): void {
+    if (this.#timer !== null) return;
+    this.#timer = setInterval(() => {
+      this.storage.sweepExpired(Date.now());
+    }, this.intervalMs);
+    // Don't keep the process alive solely for the reaper.
+    this.#timer.unref?.();
+  }
+
+  stop(): void {
+    if (this.#timer !== null) {
+      clearInterval(this.#timer);
+      this.#timer = null;
+    }
+  }
+}

package/src/sidecar/watch.ts

@@ -0,0 +1,33 @@
+/**
+ * WatchRegistry — optimistic-lock version tracking for MULTI/WATCH/EXEC.
+ *
+ * Under the single-writer assumption (§5.3), correctness only requires detecting
+ * whether any watched key was modified between WATCH and EXEC. We keep an
+ * in-process monotonic version per key, bumped on every write. WATCH snapshots
+ * the current versions; EXEC compares. A missing key has version 0.
+ */
+
+export class WatchRegistry {
+  #versions = new Map<string, number>();
+
+  /** Bump a key's version. Called by storage on every mutation. */
+  bump = (key: Uint8Array): void => {
+    const k = hashKey(key);
+    this.#versions.set(k, (this.#versions.get(k) ?? 0) + 1);
+  };
+
+  /** Current version of a key (0 if never written). */
+  version(key: Uint8Array): number {
+    return this.#versions.get(hashKey(key)) ?? 0;
+  }
+}
+
+/** A connection's WATCH snapshot: key (as hash) → version observed at WATCH. */
+export type WatchSnapshot = Map<string, { key: Uint8Array; version: number }>;
+
+/** Stable map-key for a byte array (latin1 round-trips every byte). */
+export function hashKey(key: Uint8Array): string {
+  let s = "";
+  for (let i = 0; i < key.length; i++) s += String.fromCharCode(key[i]!);
+  return s;
+}