jsql-neo 4.3.0 → 4.4.1

package/README.md

@@ -1,165 +1,289 @@
-# JSQL-NEO v4.0.1
+# JSQL-NEO
 
-Rust-powered embedded database with **three engines + SQL + Redis-style storage** in one npm package.
+> **One engine to rule them all** — a Rust-powered embedded database that speaks your language:
+> MySQL protocol. Redis protocol. SQL. TypeScript. The browser. **And it fits in one npm package.**
 
-## Engines
+![Engines](https://img.shields.io/badge/engines-Native%20%7C%20WASM%20%7C%20Pure%20JS-7ee787)
+![MySQL](https://img.shields.io/badge/protocol-MySQL%20compatible-1f6feb)
+![Redis](https://img.shields.io/badge/protocol-Redis%20RESP2-f03c15)
+![ZERO](https://img.shields.io/badge/dependencies-ZERO-8957e5)
+![WASM](https://img.shields.io/badge/runs%20in-Browser%20%28WASM%29-79c0ff)
+
+---
+
+## Why JSQL-NEO?
+
+Most embedded databases make you choose: *native speed*, *portable WASM*, or *a familiar file format*.
+JSQL-NEO gives you **all three in one install** — plus drop-in compatibility with the **two most popular
+database protocols in the world**.
+
+- ⚡ **Rust core** — N-API native addon, ~2× faster than better-sqlite3 (see [Benchmark](#benchmark))
+- 🧩 **WASM build** — the *same engine* runs in Node.js **and any browser**, zero native deps
+- 🐘 **MySQL protocol** — Sequelize, Knex, TypeORM, mysql2, phpMyAdmin … **just work**, no plugin
+- 🐇 **Redis protocol** — ioredis, node-redis, redis-cli — strings, hashes, lists, sets, TTL, snapshots
+- 🌐 **Built-in Web UI** — a zero-dependency management console ships with the package
+- 🗃️ **Three storage modes** — memory-first, hybrid (LRU + async flush), and disk
+- 📦 **Zero runtime dependencies** — the whole world is your `node_modules`
+- 🏷️ **Typed** — full TypeScript declarations for every API surface
 
-| Engine | Entry | Use Case |
-|--------|-------|----------|
-| **Native** (Rust → N-API, fastest) | `NativeJSQL` | Node.js, best performance |
-| **WASM** (Rust → wasm-pack, zero native deps) | `JSQL` | Node.js / browsers, no native addon |
-| **Pure JS** (local JSON file, SQLite-like) | `Database` | Local file persistence, legacy API |
+```
+            ┌─────────────────────────── JSQL-NEO ───────────────────────────┐
+            │                                                               │
+  Node.js ──┤  Native (Rust N-API)     Fastest path, zero deps              │
+  Node.js ──┤  WASM   (Rust → wasm)    Portable, no native addon            │
+  Browser ──┤  WASM   (+ IndexedDB)    Full SQL engine in your browser      │
+  Anywhere ─┤  Pure JS (JSON file)     SQLite-like local persistence        │
+            │                                                               │
+            ├── speak MySQL ──────────► Sequelize / Knex / TypeORM / mysql2 │
+            ├── speak Redis ──────────► ioredis / node-redis / redis-cli    │
+            ├── speak HTTP ───────────► built-in Web UI + management APIs   │
+            └── speak SQL ────────────► CREATE / SELECT / JOIN / aggregates │
+                                                                             ┘
+```
 
-All engines share the same API (`createTable` / `insert` / `findById` / `find` / `updateById` / `removeById` / `dropTable`) plus `executeSQL()`.
+## 30-second Quick Start
 
-## SQL
+```bash
+npm install jsql-neo
+```
 
 ```js
 const jsql = require('jsql-neo');
-const db = new jsql.NativeJSQL();
+const db = new jsql.NativeJSQL();          // fastest engine
 await db.start();
 
 await jsql.executeSQL(db, 'CREATE TABLE users (id INTEGER PRIMARY KEY AUTO_INCREMENT, name STRING, age INTEGER)');
-await jsql.executeSQL(db, "INSERT INTO users (name, age) VALUES ('Alice', 30), ('Bob', 25)");
-await jsql.executeSQL(db, "INSERT INTO users VALUES (5, 'Carol', 35) ON DUPLICATE KEY UPDATE age = 30");
+await jsql.executeSQL(db, "INSERT INTO users (name, age) VALUES ('Alice', 30), ('Bob', 25), ('Carol', 35)");
 const r = await jsql.executeSQL(db, 'SELECT name, age FROM users WHERE age > 26 ORDER BY age DESC');
-// → rows: [["Carol",35],["Alice",30]]
+// rows: [["Carol",35],["Alice",30]]
 
-await jsql.executeSQL(db, 'UPDATE users SET age = 31 WHERE id = 1');
-await jsql.executeSQL(db, 'DELETE FROM users WHERE id = 2');
 await db.stop();
 ```
 
-Supported: `CREATE/DROP TABLE`, `INSERT` (multi-row, `ON DUPLICATE KEY UPDATE`), `SELECT` (`WHERE`/`ORDER BY`/`LIMIT`/`OFFSET`/`GROUP BY`/`HAVING`/aggregates), `UPDATE`, `DELETE`, prepared statements with `?` placeholders.
+Need a **MySQL server** instead?
+
+```bash
+jsql serve -p 3306 --data-dir ./data
+mysql -h 127.0.0.1 -P 3306 -u root        # any MySQL client, now
+```
+
+Need a **Redis server**?
+
+```bash
+jsql redis -p 6379 --data-dir ./redis-data
+redis-cli SET hello world
+```
+
+Need a **web console**?
+
+```bash
+jsql ui -p 8080 --data-dir ./data         # open http://localhost:8080
+```
+
+One package. One install. Five doors in.
+
+---
+
+## Engines
 
-## Redis-Style Storage Modes
+| Engine | Entry point | Speed | Where it runs | Best for |
+|--------|-------------|-------|---------------|----------|
+| **Native** | `NativeJSQL` | ⚡ fastest (Rust N-API) | Node.js | Production, hot paths |
+| **WASM** | `JSQL` | fast (Rust → wasm) | Node.js **and browsers** | Portability, edge, playgrounds |
+| **Pure JS** | `Database` | solid | Node.js | Local JSON files, zero-native deploys |
 
-Native and Pure JS engines support three persistence modes (Redis-compatible model: memory-first, async flush, LRU eviction, lazy reload):
+All three share the same API — `createTable` / `insert` / `findById` / `find` / `updateById` /
+`removeById` / `dropTable` — plus a common `executeSQL()` SQL engine. **Write once, run anywhere.**
+
+### Storage modes (Native & Pure JS)
+
+| Mode | Behavior |
+|------|----------|
+| `memory` | Pure in-memory, max speed, no path needed |
+| `hybrid` | Memory-first, async incremental flush, cold tables LRU-evicted under memory pressure, lazy reload |
+| `disk` | Fast flush (50ms), memory as read/write cache |
 
 ```js
 const db = new jsql.NativeJSQL({
-  path: '/var/lib/jsql',        // storage directory (required for hybrid/disk)
-  mode: 'hybrid',               // 'memory' (default) | 'hybrid' | 'disk'
-  memReserveMB: 512,            // keep 512MB RAM headroom before evicting
-  flushInterval: 200,           // ms between async flushes (hybrid 200 / disk 50)
-  evictInterval: 1000,          // ms between memory-pressure checks
+  path: '/var/lib/jsql',
+  mode: 'hybrid',           // 'memory' | 'hybrid' | 'disk'
+  memReserveMB: 512,        // RAM headroom before LRU eviction
+  flushInterval: 200,       // async flush cadence (ms)
 });
-await db.start();
 ```
 
-- **`memory`** — pure in-memory (default, no path needed)
-- **`hybrid`** — writes go to memory first, async incremental flush to disk; cold tables are LRU-evicted when memory pressure exceeds `total - memReserveMB`, and lazily reloaded on next access
-- **`disk`** — fast flush (50ms), memory acts as read/write cache
+Atomic writes (tmp + rename), per-table files, and WAL + snapshot crash recovery on the server engine.
 
-Data is stored per-table as `<dir>/<table>.jsql.json` + `meta.json`; writes are atomic (tmp + rename).
+---
 
-```js
-// Pure JS engine (same options)
-const db2 = new jsql.Database({ path: '/var/lib/jsql', mode: 'hybrid' });
+## The SQL Engine
+
+A full SQL engine with prepared statements, joins, subqueries, and MySQL-compatible column naming:
+
+```sql
+CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY AUTO_INCREMENT, name VARCHAR(50), age INTEGER)
+INSERT INTO users (name, age) VALUES ('Alice', 30), ('Bob', 25) ON DUPLICATE KEY UPDATE age = 30
+SELECT name, age FROM users WHERE age > 26 ORDER BY age DESC LIMIT 10 OFFSET 5
+SELECT COUNT(*), AVG(age) FROM users GROUP BY dept HAVING COUNT(*) > 2
+UPDATE users SET age = 31 WHERE name = 'Bob'
+DELETE FROM users WHERE id = 2
+BEGIN / COMMIT / ROLLBACK
 ```
 
-## Quick Start
+Scalar functions: `VERSION()`, `NOW()`, `CONCAT()`, `IFNULL()`, `COALESCE()`, `UPPER()`, `LOWER()`,
+`LENGTH()`, `ROUND()`, `LAST_INSERT_ID()`, `ROW_COUNT()`, `FOUND_ROWS()`, `CONNECTION_ID()`, `DATABASE()` …
+System variables: `@@version`, `@@sql_mode`, `SET @@sql_mode = 'STRICT_TRANS_TABLES'` …
+
+---
+
+## Speak MySQL
 
-### Native (fastest)
+The MySQL wire-protocol server accepts **standard MySQL clients** — no plugins, no middleware.
+Verified in CI against the real drivers used by three major ORMs:
+
+| ORM | Version | Results |
+|-----|---------|---------|
+| [Sequelize](https://sequelize.org) | v6 | ✅ 10/10 — connect, authenticate, sync, create, bulkCreate, find, count, update, destroy, MAX() |
+| [Knex](https://knexjs.org) | v3 | ✅ 9/9 — schema builder, insert, select, where + orderBy, count, update, delete, raw SQL |
+| [TypeORM](https://typeorm.io) | v0.3 | ✅ 8/8 — initialize, synchronize, save, findOne, find, count, update, delete |
+
+Also verified with `mysql2/promise` over the wire: prepared statements (`COM_STMT_PREPARE`/`EXECUTE`),
+binary protocol result sets, `SHOW COLUMNS` / `SHOW INDEX` / `SHOW CREATE TABLE` / `SHOW VARIABLES` /
+`SHOW GRANTS`, `information_schema`, `START TRANSACTION`, `TRUNCATE TABLE`, `SET` statements, and
+MySQL DDL forms (`int unsigned`, `auto_increment`, `ENGINE=InnoDB`, `DEFAULT CHARSET`).
 
 ```js
-const { NativeJSQL } = require('jsql-neo');
-const db = new NativeJSQL();
-await db.start();
+const { createMysqlServer } = require('jsql-neo');
+createMysqlServer({ port: 3306, dataDir: './data', noAuth: true }).listen();
+```
 
-await db.createTable('users', {
-  name: { type: 'string' },
-  age:  { type: 'integer' }
-});
-const [id] = await db.insert('users', { name: 'Alice', age: 30 });
-const user = await db.findById('users', id);
-// → { id: 1, fields: { name: 'Alice', age: 30 }, created_at: '...', updated_at: '...' }
-await db.stop();
+---
+
+## Speak Redis
+
+A RESP2 server that plays perfectly with `ioredis`, `node-redis`, and `redis-cli`:
+
+```
+PING ECHO SET GET SETNX DEL EXISTS KEYS TYPE EXPIRE TTL PERSIST
+INCR DECR INCRBY DECRBY APPEND STRLEN
+HSET HGET HGETALL HDEL HEXISTS HLEN HKEYS HVALS
+LPUSH RPUSH LPOP RPOP LLEN LRANGE LINDEX LREM
+SADD SREM SMEMBERS SISMEMBER SCARD
+DBSIZE FLUSHALL FLUSHDB SELECT INFO AUTH QUIT
 ```
 
-### Pure JS (local file)
+Snapshot persistence to `data.rdb.json` — debounced writes (500ms) plus a guaranteed flush on shutdown.
 
 ```js
-const { Database } = require('jsql-neo');
-const db = new Database('/tmp/mydb.json');   // or { path, mode } for hybrid/disk
-const users = db.createTable('users', {
-  id:   { type: 'integer', autoIncrement: true, primaryKey: true },
-  name: { type: 'string', length: 32 },
-  age:  { type: 'integer' }
-});
-const ids = users.insertMany([{ name: 'Alice', age: 30 }, { name: 'Bob', age: 25 }]);
-users.updateById(ids[0], { age: 31 });
-db.save();
+const { createRedisServer } = require('jsql-neo');
+createRedisServer({ port: 6379, dataDir: './redis-data' }).listen();
+```
+
+---
+
+## Toolbox — everything included
+
+### CLI (`jsql`)
+
+| Command | What it does |
+|---------|--------------|
+| `jsql serve` | Run the MySQL-compatible server in the foreground |
+| `jsql server start\|stop\|status` | Background daemon with pid control |
+| `jsql redis` | Run the Redis-compatible server |
+| `jsql ui` | Serve the built-in web management console |
+| `jsql import <dump.sql\|.json\|.csv>` | Load a mysqldump, JSON, or CSV file |
+| `jsql export <table> <file>` | Dump a table to JSON or CSV |
+| `jsql bench` | Insert + query benchmark against a data dir |
+| `jsql mod` | Plugin registry (enable / disable / list) |
+| `jsql version` | Print version |
+
+### Web UI (`WebUI`)
+
+A zero-dependency HTTP management console: browse databases and tables, run SQL in the browser,
+see results as a table. Perfect for dev tools, admin panels, and demos.
+
+### Migration tools (`migrate`)
+
+```js
+const { importDumpFile, exportToFile, importFromCSV, exportAllToJSON } = require('jsql-neo');
+await importDumpFile(db, './backup.sql', { strict: true });   // real mysqldump format
+await exportToFile(db, 'users', './users.csv');               // CSV round-trip
+```
+
+### Browser playground
+
+`examples/playground/` is a self-contained SQL sandbox — the **entire engine runs in your browser**
+(WASM + IndexedDB persistence, no server):
+
+```bash
+cd examples/playground && npm install && npm run dev
+```
+
+### TypeScript
+
+Full declarations ship with the package (`index.d.ts` + `wasm/browser.d.ts`), verified with
+`tsc --strict`. Autocomplete your way through every engine, server, and tool.
+
+---
+
+## Benchmark
+
+100,000 rows — insert / point query / range query / count / update (Linux x64, Node 24):
+
+| Engine | Insert/s | Point query (500×) | Range query (500×) | Total |
+|--------|----------|--------------------|--------------------|-------|
+| **Native (Rust N-API)** | 0.66M | 930ms | 685ms | **1.77s** 🏆 |
+| better-sqlite3 (WAL) | 0.40M | 3258ms | 149ms | 3.66s |
+| sql.js (WASM sqlite) | 0.30M | 5852ms | 366ms | 6.57s |
+| Pure JS engine | 0.38M | 11278ms | 18138ms | 29.7s |
+
+**~2× faster than better-sqlite3. ~17× faster than a pure-JS engine.** Reproduce it yourself:
+
+```bash
+cd bench && npm install && npm run bench
 ```
 
-## API
+---
+
+## API at a glance
 
-| Method | Native | WASM | Pure JS | Description |
-|--------|--------|------|---------|-------------|
-| `createTable(name, schema)` | ✅ | ✅ | ✅ | Define table with typed fields |
-| `insert(table, data)` | ✅ | ✅ | ✅ | Insert row(s), returns IDs |
-| `findById(table, id)` | ✅ | ✅ | ✅ | O(1) PK lookup |
-| `find(table, filter?)` | ✅ | ✅ | ✅ | Filtered query with B-Tree index |
-| `count(table)` | ✅ | ✅ | ✅ | Row count |
+| Method | Native | WASM | Pure JS | Notes |
+|--------|:------:|:----:|:-------:|-------|
+| `createTable(name, schema)` | ✅ | ✅ | ✅ | Typed fields, indexes |
+| `insert(table, data)` | ✅ | ✅ | ✅ | Batch supported, returns IDs |
+| `findById(table, id)` | ✅ | ✅ | ✅ | O(1) primary-key hash lookup |
+| `find(table, filter, opts)` | ✅ | ✅ | ✅ | Filter + B-Tree range scan, pagination |
+| `count(table)` | ✅ | ✅ | ✅ | — |
 | `updateById(table, id, data)` | ✅ | ✅ | ✅ | O(1) PK update |
 | `removeById(table, id)` | ✅ | ✅ | ✅ | O(1) PK delete |
-| `dropTable(name)` | ✅ | ✅ | ✅ | Remove table |
-| `executeSQL(db, sql, params?)` | ✅ | ✅ | ✅ | Run SQL statements |
-
-## Schema Field Options
+| `executeSQL(db, sql, params)` | ✅ | ✅ | ✅ | Full SQL engine, prepared statements |
 
 ```js
 {
   type: 'string' | 'integer' | 'float' | 'boolean',
-  primaryKey: true,       // PK field (auto-indexed)
-  autoIncrement: true,    // Auto-generate integer PK
-  length: 32,             // Max string length
-  default: 'value',       // Default value
-  nullable: true          // Allow null
+  primaryKey: true,       // auto-indexed
+  autoIncrement: true,    // integer PK generation
+  length: 32,             // string max length
+  default: 'value',
+  nullable: true
 }
 ```
 
-## ORM Compatibility
+---
 
-The MySQL-compatible server mode accepts standard MySQL clients, so popular Node.js ORMs work without a plugin. Tested against a live `createMysqlServer()` instance:
+## Testing
 
-| ORM | Version | Results |
-|-----|---------|---------|
-| [Sequelize](https://sequelize.org) | v6 | ✅ 10/10 — connect, authenticate, sync (CREATE TABLE), create, bulkCreate, find, count, update, destroy, MAX() |
-| [Knex](https://knexjs.org) | v3 | ✅ 9/9 — schema builder, insert, select, where + orderBy, count, update, delete, raw `SELECT VERSION()` |
-| [TypeORM](https://typeorm.io) | v0.3 | ✅ 8/8 — initialize, synchronize, save, findOne, find, count, update, delete |
-
-```js
-// Sequelize
-const { Sequelize, DataTypes } = require('sequelize');
-const sequelize = new Sequelize('default', 'root', '', {
-  host: '127.0.0.1', port: 33306, dialect: 'mysql',
-});
+```bash
+npm test          # zero-dependency SQL engine smoke suite
+npm run test:orms # ORM compatibility (start examples/orms/start-server.js first)
+```
 
-// Knex
-const knex = require('knex')({
-  client: 'mysql2',
-  connection: { host: '127.0.0.1', port: 33306, user: 'root', database: 'default' },
-});
+CI (`.github/workflows/ci.yml`): engine smoke tests on Node 18/20/22 + a full ORM compatibility job.
 
-// TypeORM
-const ds = new DataSource({
-  type: 'mysql',
-  host: '127.0.0.1', port: 33306, username: 'root', database: 'default',
-  synchronize: true, entities: [User],
-});
-```
+---
 
-Supported for ORM compatibility: prepared statements (`COM_STMT_PREPARE`/`EXECUTE`), binary protocol result sets, `SHOW COLUMNS` / `SHOW INDEX` / `SHOW CREATE TABLE` / `SHOW VARIABLES` / `SHOW GRANTS`, `information_schema` queries, `START TRANSACTION`, `TRUNCATE TABLE`, `SET` statements, scalar functions (`VERSION()`, `NOW()`, `CONCAT()`, `IFNULL()`, ...), and MySQL DDL forms (`int unsigned`, `auto_increment`, `ENGINE=InnoDB`, `DEFAULT CHARSET`).
+## License
 
-## Features
+MIT — use it, ship it, love it.
 
-- Three engines: Native (N-API Rust), WASM (wasm-pack Rust), Pure JS (local JSON)
-- SQL engine with prepared statements
-- Redis-style hybrid/disk storage: memory-first + async flush + LRU eviction + lazy reload
-- O(1) primary key hash index (`FxHashMap` / `Map`)
-- B-Tree indexing for range queries
-- WAL + snapshot crash recovery (server engine)
-- Batch insert / update / delete
-- Cursor-based pagination
-- Transaction support (server engine)
+*JSQL-NEO: Rust-powered. Protocol-native. One package.*

package/bin/jsql

@@ -1,6 +1,10 @@
 #!/usr/bin/env node
+const path = require('path');
+const fs = require('fs');
 const yaggs = require('@vexify-org/yaggs');
 const { ModuleManager } = require('../lib/mod');
+const Database = require('../lib/database');
+const migrate = require('../lib/migrate');
 
 function printModules(list) {
   if (list.length === 0) {
@@ -93,6 +97,140 @@ const cli = yaggs()
       fail(e);
     }
   })
+  .command('export', 'Export a table to JSON or CSV', (sub) => {
+    sub.option('db', { type: 'string', description: 'Database file path (default ./db.json)' });
+    sub.option('json', { type: 'boolean', description: 'Output metadata as JSON' });
+  }, async (argv) => {
+    const table = argv._[0];
+    const outFile = argv._[1];
+    const fail = (e) => { console.error(`Error: ${e.message}`); process.exitCode = 1; };
+    try {
+      if (!table || !outFile) throw new Error('Usage: jsql export <table> <file.json|csv> [--db <path>]');
+      const db = new Database(argv.db || './db.json', { autoSave: false });
+      await db.loadDatabase ? db.loadDatabase() : null;
+      const bytes = await migrate.exportToFile(db, table, outFile);
+      if (argv.json) console.log(JSON.stringify({ ok: true, table, file: outFile, bytes }));
+      else console.log(`Exported '${table}' (${bytes} bytes) to ${outFile}`);
+    } catch (e) { fail(e); }
+  })
+  .command('import', 'Import a mysqldump (.sql), JSON (.json) or CSV (.csv) file', (sub) => {
+    sub.option('db', { type: 'string', description: 'Database file path (default ./db.json)' });
+    sub.option('table', { type: 'string', description: 'Target table for CSV import' });
+    sub.option('strict', { type: 'boolean', description: 'Abort on first import error' });
+    sub.option('json', { type: 'boolean', description: 'Output metadata as JSON' });
+  }, async (argv) => {
+    const file = argv._[0];
+    const fail = (e) => { console.error(`Error: ${e.message}`); process.exitCode = 1; };
+    try {
+      if (!file) throw new Error('Usage: jsql import <file.sql|.json|.csv> [--db <path>] [--table <name>]');
+      const db = new Database(argv.db || './db.json', { autoSave: false });
+      await db.loadDatabase ? db.loadDatabase() : null;
+      const ext = path.extname(file).toLowerCase();
+      let result;
+      if (ext === '.sql') {
+        result = await migrate.importDumpFile(db, file, { strict: !!argv.strict });
+      } else if (ext === '.json') {
+        const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+        result = await migrate.importFromJSON(db, data);
+      } else if (ext === '.csv') {
+        if (!argv.table) throw new Error('CSV import requires --table <name>');
+        const schemaFile = file.replace(/\.csv$/i, '.schema.json');
+        const schema = fs.existsSync(schemaFile) ? JSON.parse(fs.readFileSync(schemaFile, 'utf8')) : null;
+        result = await migrate.importFromCSV(db, argv.table, fs.readFileSync(file, 'utf8'), { schema });
+      } else {
+        throw new Error('Unsupported file type: ' + ext);
+      }
+      if (argv.json) {
+        console.log(JSON.stringify({ ok: true, ...result }));
+      } else {
+        const errs = result.errors && result.errors.length;
+        console.log(`Imported: ${result.created ? result.created.length + ' table(s), ' : ''}${result.inserted || 0} row(s)` + (errs ? `, ${errs} error(s)` : ''));
+      }
+    } catch (e) { fail(e); }
+  })
+  .command('serve', 'Run the MySQL-compatible server in the foreground', (sub) => {
+    sub.option('port', { alias: 'p', type: 'number', description: 'Listen port (default 3306)' });
+    sub.option('host', { type: 'string', description: 'Listen host (default 127.0.0.1)' });
+    sub.option('data-dir', { type: 'string', description: 'Directory to store databases' });
+    sub.option('no-auth', { type: 'boolean', description: 'Allow connections without authentication' });
+    sub.option('log', { type: 'boolean', description: 'Log queries to stdout' });
+  }, async (argv) => {
+    const { createMysqlServer } = require('../lib/mysql_server');
+    const options = {
+      port: argv.port != null ? argv.port : 3306,
+      host: argv.host || '127.0.0.1',
+      dataDir: argv['data-dir'],
+      noAuth: argv['no-auth'] === true,
+    };
+    if (argv.log) options.onQuery = (q) => console.log('[sql]', q);
+    const srv = createMysqlServer(options);
+    srv.listen();
+    console.log(`jsql-neo MySQL server on ${options.host}:${options.port}${options.dataDir ? ' (data: ' + options.dataDir + ')' : ' (in-memory)'}`);
+    setInterval(() => {}, 1 << 30);
+  })
+  .command('bench', 'Insert + query benchmark against a data directory', (sub) => {
+    sub.option('n', { type: 'number', description: 'Number of rows (default 10000)' });
+    sub.option('data-dir', { type: 'string', description: 'Data directory (default :memory:)' });
+    sub.option('json', { type: 'boolean', description: 'Output as JSON' });
+  }, async (argv) => {
+    const N = argv.n || 10000;
+    const dataDir = argv['data-dir'] || ':memory:';
+    try {
+      const db = new Database(dataDir === ':memory:' ? ':memory:' : path.join(dataDir, 'bench.json'), { autoSave: false });
+      await db.createTable('bench', { id: { type: 'integer', primaryKey: true, autoIncrement: true }, name: { type: 'string' }, score: { type: 'float' } });
+      let t0 = Date.now();
+      const batch = [];
+      for (let i = 0; i < N; i++) batch.push({ name: 'user_' + i, score: Math.random() * 1000 });
+      for (let i = 0; i < batch.length; i += 1000) await db.insert('bench', batch.slice(i, i + 1000));
+      const insertMs = Date.now() - t0;
+      t0 = Date.now();
+      let hits = 0;
+      for (let i = 0; i < 100; i++) hits += (await db.find('bench', { score: { $gt: 500 } }, { limit: 10 })).length;
+      const queryMs = Date.now() - t0;
+      const total = await db.count('bench');
+      const out = { ok: true, rows: N, inserted: total, insertMs, insertPerSec: Math.round(N / (insertMs / 1000)), queryMs, queryCount: 100 };
+      if (argv.json) console.log(JSON.stringify(out));
+      else console.log(`Inserted ${total} rows in ${insertMs}ms (${out.insertPerSec}/s), 100 queries in ${queryMs}ms`);
+    } catch (e) { console.error(`Error: ${e.message}`); process.exitCode = 1; }
+  })
+  .command('ui', 'Serve the built-in web management console', (sub) => {
+    sub.option('port', { alias: 'p', type: 'number', description: 'HTTP port (default 8080)' });
+    sub.option('host', { type: 'string', description: 'Listen host (default 0.0.0.0)' });
+    sub.option('data-dir', { type: 'string', description: 'Directory containing *.json databases (default .)' });
+    sub.option('readonly', { type: 'boolean', description: 'Never write back to disk' });
+  }, async (argv) => {
+    const { WebUI } = require('../lib/web_ui');
+    const ui = new WebUI({
+      port: argv.port != null ? argv.port : 8080,
+      host: argv.host || '0.0.0.0',
+      dataDir: argv['data-dir'] || '.',
+      readonly: argv.readonly === true,
+    });
+    try {
+      const port = await ui.start();
+      console.log(`JSQL-NEO web UI on http://${argv.host || '0.0.0.0'}:${port} (data: ${ui.dataDir})`);
+      setInterval(() => {}, 1 << 30);
+    } catch (e) { console.error(`Error: ${e.message}`); process.exitCode = 1; }
+  })
+  .command('redis', 'Run the Redis-compatible server', (sub) => {
+    sub.option('port', { alias: 'p', type: 'number', description: 'Listen port (default 6379)' });
+    sub.option('host', { type: 'string', description: 'Listen host (default 127.0.0.1)' });
+    sub.option('data-dir', { type: 'string', description: 'Directory for data.rdb.json snapshot' });
+    sub.option('auth', { type: 'string', description: 'Require this password for AUTH' });
+    sub.option('log', { type: 'boolean', description: 'Log commands to stdout' });
+  }, (argv) => {
+    const { createRedisServer } = require('../lib/redis_server');
+    const srv = createRedisServer({
+      port: argv.port != null ? argv.port : 6379,
+      host: argv.host || '127.0.0.1',
+      dataDir: argv['data-dir'],
+      password: argv.auth || null,
+      onQuery: argv.log ? (c) => console.log('[redis]', c.join(' ')) : null,
+    });
+    srv.listen();
+    console.log(`jsql-neo Redis server on ${argv.host || '127.0.0.1'}:${argv.port != null ? argv.port : 6379}${argv['data-dir'] ? ' (data: ' + argv['data-dir'] + ')' : ''}`);
+    setInterval(() => {}, 1 << 30);
+  })
   .command('version', 'Show version', null, () => {
     console.log(require('../package.json').version);
   })