A Redis-compatible server built from scratch in Node.js — implementing the RESP protocol, dual-layer persistence (AOF + RDB), master/replica replication, Pub/Sub messaging, and transactions. Comes with an interactive React sandbox to explore commands and visualise internal storage in real time.

Try it → https://abhinov007.github.io/Redis_Clone/

Type Redis commands and watch the internal database, expiry store, AOF log, RDB snapshot, and Pub/Sub channels update live.

• RESP Protocol — full Redis Serialization Protocol parser with incremental TCP chunk handling
• 4 data types — Strings, Lists, Hashes, Sets
• Key-space completeness — multi-key duplicate-aware EXISTS, key type inspection (TYPE), atomic key renaming with TTL preservation (RENAME), and Redis-compliant glob pattern matches (*, ?, [a-z]) via converted regular expressions (KEYS).
• String & List completeness — conditional writes (SETNX), multiple key mutations/fetches (MSET/MGET), value appending (APPEND), key length fetching (STRLEN), delta mutators (INCRBY/DECRBY), and bounds-safe negative-indexed list operations (LINDEX, LSET, LTRIM with auto-deletion on empty).
• Key expiry — SET key value EX seconds, lazy eviction on read + active probabilistic sweep every 100 ms
• 60+ commands across all data types

• AOF — every write appended to database.aof; replayed on startup via the live command handler (no duplicate parser)
• RDB — debounced async JSON snapshot to dump.rdb; blocks only on graceful shutdown
• Priority rule — AOF takes precedence over RDB on startup (matches Redis behaviour, prevents double-apply of mutations)

• MULTI / EXEC / DISCARD — commands queued and executed atomically; per-command error isolation inside EXEC

• SUBSCRIBE / UNSUBSCRIBE / PUBLISH
• Channel → subscriber socket mapping with automatic cleanup on disconnect

• Master generates a replication ID and maintains a 1 MB circular backlog
• Full resync (RDB snapshot) and partial resync (+CONTINUE from backlog offset)
• Replica 6-state handshake with auto-reconnect and REPLCONF ACK heartbeats
• Write commands propagated to all replicas in RESP format
• Replica enforces read-only mode for client connections

• Error boundary — any unhandled exception inside a command returns -ERR to the client; server keeps running
• Graceful shutdown — SIGINT / SIGTERM flush a final synchronous RDB snapshot before exit
• Active expiry sweep — probabilistic Fisher-Yates sample, re-sweeps immediately when >25 % of sample expired

redis_clone/
├── server.js                     # TCP server entry point
├── startup.js                    # Persistence loading + replica init
├── RESPParser.js                 # Incremental RESP protocol parser
├── client.js                     # Interactive CLI client
│
├── commands/
│   └── command.js                # All 60+ command handlers
│
├── middleware/
│   ├── transactions.js           # MULTI/EXEC/DISCARD + command queue
│   └── replication.js            # Read-only guard, REPLCONF/PSYNC routing
│
├── storage/
│   ├── database.js               # In-memory Map store (string/list/hash/set)
│   └── expiry.js                 # TTL store, lazy + active sweep eviction
│
├── persistence/
│   ├── aof.js                    # Append-Only File (dependency-injected replay)
│   └── rdb.js                    # Debounced async JSON snapshot
│
├── protocol/
│   └── resp.js                   # RESP encoding helpers
│
├── messaging/
│   └── pubsub.js                 # Pub/Sub channel → socket mapping
│
├── replication/
│   ├── master.js                 # Replication ID, backlog, propagation
│   └── replica.js                # 6-state handshake + streaming state machine
│
├── tests/
│   ├── phase1Test.js             # Stability: async RDB, error boundary, shutdown (11 tests)
│   ├── phase2Test.js             # Correctness: expiry sweep, AOF replay, INCR/DECR (14 tests)
│   ├── phase3Test.js             # Completeness: key-space, strings, lists, sets (55 tests)
│   ├── loadTest.js               # Throughput / latency benchmark with histogram
│   ├── TestParser.js             # RESP parser smoke test
│   ├── clientTest.js             # SET/GET integration test
│   └── replicationTest.js        # Replication suite (18 tests)
│
├── workflow.html                 # Interactive Mermaid architecture diagrams
│
└── sandbox/                      # React + Vite interactive browser sandbox
    ├── src/
    │   ├── engine/               # Browser simulation of server internals
    │   │   ├── database.js
    │   │   ├── expiry.js
    │   │   ├── commands.js
    │   │   ├── aof.js
    │   │   ├── rdb.js
    │   │   └── pubsub.js
    │   ├── components/
    │   │   ├── Terminal.jsx      # REPL with command history
    │   │   ├── StorageInspector.jsx  # 5-tab storage visualiser
    │   │   ├── KeyCard.jsx       # Per-key card with live TTL countdown
    │   │   └── ResponseLine.jsx  # Colour-coded RESP response renderer
    │   ├── hooks/
    │   │   └── useRedisEngine.js # Central state hook (useRef engine, useState snapshots)
    │   └── App.jsx
    ├── vite.config.js
    └── package.json

• Node.js v18+

node server.js

Server starts on port 6379 by default.

# Custom port
node server.js --port 6380

# Start as a replica of another instance
node server.js --port 6380 --replicaof localhost 6379

# Built-in CLI client
node client.js

# netcat (inline commands)
echo -e "*1\r\n\$4\r\nPING\r\n" | nc localhost 6379

Terminal 1 — Master

node server.js

Terminal 2 — Replica

node server.js --port 6380 --replicaof localhost 6379

Writes on the master propagate automatically. The replica does a full RDB sync on first connect and a partial resync on reconnect using the replication backlog.

Terminal 1 — Subscriber

node client.js   # then type: SUBSCRIBE news

Terminal 2 — Publisher

node client.js   # then type: PUBLISH news "Hello World"

Each suite is self-contained — it spawns its own server instance(s) on isolated ports and cleans up after itself.

# Stability (async RDB, error boundary, graceful shutdown)
node tests/phase1Test.js

# Correctness (active expiry, AOF replay across all types, INCR/DECR)
node tests/phase2Test.js

# Completeness (60+ commands: key-space, strings, lists, sets)
node tests/phase3Test.js

# Performance benchmark (throughput, p50/p95/p99 latency, histogram)
node tests/loadTest.js [clients] [requestsPerClient] [set|get|mix|pipeline]

Run all suites in sequence:

node tests/phase1Test.js && node tests/phase2Test.js && node tests/phase3Test.js

node tests/loadTest.js 100 500 mix

The sandbox/ directory is a React + Vite app that simulates the server entirely in the browser. No server or Node.js needed.

cd sandbox
npm install
npm run dev

Open http://localhost:5173 to explore:

Open workflow.html in a browser for interactive Mermaid diagrams covering:

• Full system overview
• Request lifecycle (GET/SET → parser → middleware → command handler → AOF/RDB → replication)
• Replication handshake and replica state machine
• Pub/Sub message flow
• Persistence write and recovery paths (AOF priority rule)
• MULTI/EXEC transaction flow
• Module dependency map

MIT