jsql-neo 4.3.0 → 4.4.0

package/README.md

@@ -152,6 +152,67 @@ const ds = new DataSource({
 
 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`).
 
+## Redis-compatible server
+
+```bash
+jsql redis -p 6379 --data-dir ./redis-data [--auth secret]
+```
+
+or from code:
+
+```js
+const { createRedisServer } = require('jsql-neo');
+createRedisServer({ port: 6379, dataDir: './redis-data' }).listen();
+```
+
+Speaks RESP2 (works with `redis-cli` / ioredis / node-redis). Strings, hashes, lists, sets, counters, TTL, `KEYS`/`EXISTS`/`DEL`, multi-select DBs, `AUTH`, and snapshot persistence to `data.rdb.json` (debounced 500ms + on shutdown).
+
+## Web UI
+
+```bash
+jsql ui -p 8080 --data-dir ./data     # then open http://localhost:8080
+```
+
+or from code: `new WebUI({ port: 8080, dataDir: './data' }).start()`. Zero-dependency management console: browse databases/tables, run SQL in the browser.
+
+## CLI
+
+`jsql serve` (foreground MySQL server), `jsql server start|stop|status` (background daemon), `jsql import <dump.sql|.json|.csv>`, `jsql export <table> <file>`, `jsql bench`, `jsql redis`, `jsql ui`, `jsql mod` (plugin registry), `jsql version`.
+
+## Browser playground
+
+`examples/playground/` is a self-contained SQL playground that runs the full engine in the browser (WASM + IndexedDB, no server):
+
+```bash
+cd examples/playground && npm install && npm run dev
+```
+
+## Testing
+
+```bash
+npm test          # zero-dependency SQL engine smoke tests
+npm run test:orms # ORM compatibility suites (start examples/orms/start-server.js first)
+```
+
+The ORM suites in `examples/orms/` run Sequelize (10/10), Knex (9/9) and TypeORM (8/8) against a live MySQL-compatible server.
+
+## Benchmark
+
+```bash
+cd bench && npm install && npm run bench
+```
+
+`bench/bench.js` compares the four engines on 100k rows (insert / point query / range query / count / update):
+
+| Engine | Insert/s | Point query (500x) | Range query (500x) | 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 | 0.38M | 11278ms | 18138ms | 29.7s |
+
+Native is ~2x faster than better-sqlite3 and ~17x faster than the pure-JS engine overall (Linux x64 / Node 24). Full breakdown: `bench/report.md`.
+
 ## Features
 
 - Three engines: Native (N-API Rust), WASM (wasm-pack Rust), Pure JS (local JSON)
@@ -163,3 +224,6 @@ Supported for ORM compatibility: prepared statements (`COM_STMT_PREPARE`/`EXECUT
 - Batch insert / update / delete
 - Cursor-based pagination
 - Transaction support (server engine)
+- Built-in web management UI (`jsql ui` / `new WebUI(...)`): browse databases & tables, run SQL from the browser
+- CLI: `jsql serve|server|import|export|bench|ui|mod|version`
+- Migration tools: mysqldump import, JSON/CSV export/import

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);
   })

package/index.d.ts

@@ -0,0 +1,351 @@
+/**
+ * JSQL-NEO — Rust-powered embedded database (Native / WASM / Pure JS)
+ * with a MySQL-compatible server mode.
+ */
+
+declare namespace JSQLNeo {
+  export type FieldType =
+    | 'string' | 'text' | 'varchar'
+    | 'integer' | 'int' | 'bigint'
+    | 'float' | 'double' | 'number'
+    | 'boolean'
+    | 'date' | 'datetime' | 'timestamp'
+    | 'object' | 'json' | 'array'
+    | 'any' | 'binary';
+
+  export interface FieldDef {
+    type: FieldType;
+    primaryKey?: boolean;
+    autoIncrement?: boolean;
+    unique?: boolean;
+    required?: boolean;
+    nullable?: boolean;
+    length?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    default?: unknown;
+    check?: string;
+    ref?: string;
+    computed?: boolean;
+  }
+
+  export type Schema = Record<string, FieldDef>;
+
+  export interface Row {
+    id: number | string;
+    fields?: Record<string, unknown>;
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: unknown;
+  }
+
+  export interface FindOptions {
+    limit?: number;
+    offset?: number;
+  }
+
+  export interface JSQLOptions {
+    dataDir?: string;
+    flushThreshold?: number;
+    modules?: boolean;
+    persistence?: boolean;
+    dbName?: string;
+  }
+
+  export type JSQLHook =
+    | 'beforeInsert' | 'afterInsert'
+    | 'beforeUpdate' | 'afterUpdate'
+    | 'beforeDelete' | 'afterDelete'
+    | 'beforeFind' | 'afterFind'
+    | 'beforeCreateTable' | 'afterCreateTable'
+    | 'beforeDropTable' | 'afterDropTable'
+    | 'beforeFlush' | 'afterFlush'
+    | 'beforeCount' | 'afterCount'
+    | 'onStart' | 'onStop';
+
+  export interface JSQLPlugin {
+    name?: string;
+    install?(db: JSQL, ctx: PluginContext): void;
+    onEvent?(event: string, data: unknown): void;
+    hooks?: Partial<Record<JSQLHook, (...args: any[]) => unknown>>;
+  }
+
+  export interface PluginContext {
+    name: string;
+    engine: JSQL;
+    plugin: JSQLPlugin;
+    on(hook: JSQLHook, fn: (...args: any[]) => unknown): JSQL;
+    onEvent(fn: (event: string, data: unknown) => void): JSQL;
+    emit(eventName: string, data: unknown): void;
+    tables(): string[];
+    hasTable(name: string): boolean;
+    getTableSchema(name: string): Schema | null;
+  }
+
+  export class JSQL {
+    constructor(opts?: JSQLOptions);
+    use(plugin: JSQLPlugin | ((db: JSQL) => void)): this;
+    on(event: JSQLHook, fn: (...args: any[]) => unknown): this;
+    onEvent(fn: (event: string, data: unknown) => void): this;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    flush(): Promise<void>;
+    createTable(name: string, schema: Schema): Promise<unknown>;
+    dropTable(name: string): Promise<unknown>;
+    insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<unknown>;
+    insertMany(table: string, data: Record<string, unknown>[]): Promise<unknown>;
+    findById(table: string, id: number | string | bigint): Promise<Row | null>;
+    findByIds(table: string, ids: Array<number | string>): Promise<Row[] | null>;
+    find(table: string, filter?: Record<string, unknown>, opts?: FindOptions): Promise<Row[]>;
+    count(table: string): Promise<number>;
+    updateById(table: string, id: number | string, data: Record<string, unknown>): Promise<unknown>;
+    updateByIds(table: string, entries: Array<[number | string, Record<string, unknown>]>): Promise<unknown>;
+    removeById(table: string, id: number | string): Promise<unknown>;
+    removeByIds(table: string, ids: Array<number | string>): Promise<unknown>;
+    hasTable(name: string): Promise<boolean>;
+    getTables(): Promise<string[]>;
+    getTableSchema(name: string): Promise<Schema | null>;
+  }
+
+  export class NativeJSQL extends JSQL {}
+
+  export interface MysqlServerOptions {
+    port?: number;
+    host?: string;
+    dataDir?: string;
+    defaultDatabase?: string;
+    noAuth?: boolean;
+    auth?: Record<string, string>;
+    allowComments?: boolean;
+    safety?: boolean;
+    maxConnections?: number;
+    handshakeTimeout?: number;
+    maxAuthFails?: number;
+  }
+
+  export class MysqlServer {
+    constructor(options?: MysqlServerOptions);
+    listen(cb?: (err?: Error) => void): this;
+    close(cb?: () => void): void;
+    readonly address: { port: number; address: string; family: string } | null;
+    listDatabases(): Promise<string[]>;
+    createDatabase(name: string, opts?: { ifNotExists?: boolean }): Promise<void>;
+    dropDatabase(name: string, opts?: { ifExists?: boolean }): Promise<void>;
+  }
+
+  export function createMysqlServer(options?: MysqlServerOptions): MysqlServer;
+
+  export interface RedisServerOptions {
+    port?: number;
+    host?: string;
+    password?: string | null;
+    dataDir?: string | null;
+    onQuery?: (cmd: string, args: string[]) => void;
+  }
+
+  export class RedisServer {
+    constructor(options?: RedisServerOptions);
+    listen(): this;
+    stop(): void;
+    execute(cmd: string, args: string[]): string | number | string[] | null | 'OK' | 'PONG';
+  }
+
+  export function createRedisServer(options?: RedisServerOptions): RedisServer;
+
+  export interface WebUIOptions {
+    port?: number;
+    host?: string;
+    dataDir?: string;
+    readonly?: boolean;
+  }
+
+  export class WebUI {
+    constructor(options?: WebUIOptions);
+    start(): Promise<number>;
+    stop(): Promise<void>;
+    listDatabases(): { name: string; tables: number }[];
+  }
+
+  export interface MigrateResult {
+    created?: string[];
+    inserted?: number;
+    errors?: { line?: number; error: string }[];
+  }
+
+  export interface MigrateTools {
+    normalizeSchema(schema: Record<string, unknown>): Record<string, unknown>;
+    parseCSV(text: string): string[][];
+    toCSV(rows: Record<string, unknown>[], columns?: string[]): string;
+    exportTableToJSON(db: unknown, table: string): { schema: unknown; rows: unknown[] };
+    exportAllToJSON(db: unknown): Record<string, unknown>;
+    importFromJSON(db: unknown, data: Record<string, unknown>): Promise<MigrateResult>;
+    exportTableToCSV(db: unknown, table: string): string;
+    importFromCSV(db: unknown, table: string, csv: string, opts?: { schema?: unknown }): Promise<MigrateResult>;
+    importDump(db: unknown, sql: string, opts?: { strict?: boolean }): Promise<MigrateResult>;
+    importDumpFile(db: unknown, file: string, opts?: { strict?: boolean }): Promise<MigrateResult>;
+    exportToFile(db: unknown, table: string, outFile: string): Promise<number>;
+  }
+
+  export const migrate: MigrateTools;
+  export function exportTableToJSON(db: unknown, table: string): { schema: unknown; rows: unknown[] };
+  export function exportAllToJSON(db: unknown): Record<string, unknown>;
+  export function importFromJSON(db: unknown, data: Record<string, unknown>): Promise<MigrateResult>;
+  export function exportTableToCSV(db: unknown, table: string): string;
+  export function importFromCSV(db: unknown, table: string, csv: string, opts?: { schema?: unknown }): Promise<MigrateResult>;
+  export function importDump(db: unknown, sql: string, opts?: { strict?: boolean }): Promise<MigrateResult>;
+  export function importDumpFile(db: unknown, file: string, opts?: { strict?: boolean }): Promise<MigrateResult>;
+  export function exportToFile(db: unknown, table: string, outFile: string): Promise<number>;
+
+  export interface ConnectionOptions {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+  }
+
+  export interface ConnectionResult {
+    insertId: number | null;
+    affectedRows: number;
+    rows: unknown[];
+    fields?: unknown[];
+  }
+
+  export class Connection {
+    constructor(options?: ConnectionOptions);
+    connect(cb?: (err?: Error) => void): void;
+    query(sql: string, params?: unknown[], cb?: (err: Error | null, result: ConnectionResult) => void): void;
+    execute(sql: string, params?: unknown[], cb?: (err: Error | null, result: ConnectionResult) => void): void;
+    beginTransaction(cb?: (err?: Error) => void): void;
+    commit(cb?: (err?: Error) => void): void;
+    rollback(cb?: (err?: Error) => void): void;
+    end(): void;
+    format(sql: string, params?: unknown[]): string;
+    escape(value: unknown): string;
+    escapeId(value: string): string;
+  }
+
+  export class Pool {
+    constructor(options?: ConnectionOptions & { max?: number });
+    query(sql: string, params?: unknown[], cb?: (err: Error | null, result: ConnectionResult) => void): void;
+    getConnection(cb: (err: Error | null, conn: Connection) => void): void;
+    end(): void;
+  }
+
+  export function createConnection(options?: ConnectionOptions): Connection;
+  export function createPool(options?: ConnectionOptions & { max?: number }): Pool;
+
+  export interface SQLResult {
+    ok: boolean;
+    type: string;
+    table?: string | null;
+    columns?: string[];
+    rows?: unknown[][];
+    raw?: unknown[];
+    affectedRows?: number;
+    insertId?: number | null;
+    ids?: unknown[];
+    error?: string;
+  }
+
+  export interface SQLOptions {
+    allowComments?: boolean;
+    safety?: boolean;
+    maxStatements?: number;
+    session?: Record<string, unknown>;
+  }
+
+  export function executeSQL(engine: unknown, sql: string, paramsOrOpts?: unknown[] | SQLOptions, opts?: SQLOptions): Promise<SQLResult>;
+  export function parseSQL(sql: string): unknown;
+  export function splitStatements(sql: string): string[];
+  export function applyParams(sql: string, values: unknown[]): string;
+  export function escapeValue(value: unknown): string;
+  export function escapeId(value: string): string;
+
+  export interface DatabaseOptions {
+    dataDir?: string;
+    persist?: boolean;
+    inMemoryOnly?: boolean;
+  }
+
+  export class Database {
+    constructor(options?: DatabaseOptions);
+    createTable(name: string, schema: Schema): Promise<unknown>;
+    insert(table: string, data: Record<string, unknown>): Promise<unknown>;
+    find(table: string, filter?: Record<string, unknown>): Promise<Row[]>;
+    update(table: string, filter: Record<string, unknown>, data: Record<string, unknown>): Promise<number>;
+    remove(table: string, filter: Record<string, unknown>): Promise<number>;
+    findOne(table: string, filter?: Record<string, unknown>): Promise<Row | null>;
+    count(table: string): Promise<number>;
+    getTables(): Promise<string[]>;
+    dropTable(name: string): Promise<void>;
+    getTableSchema(name: string): Promise<Schema | null>;
+  }
+
+  export class Table {
+    constructor(name: string, schema: Schema, db?: unknown);
+    insert(data: Record<string, unknown>): Promise<unknown>;
+    find(filter?: Record<string, unknown>): Promise<Row[]>;
+    updateById(id: number | string, data: Record<string, unknown>): Promise<unknown>;
+    removeById(id: number | string): Promise<unknown>;
+    count(): Promise<number>;
+  }
+
+  export class Query {
+    constructor(table: unknown);
+    exec(): Promise<Row[]>;
+    then(resolve: (rows: Row[]) => unknown, reject?: (err: Error) => unknown): Promise<unknown>;
+  }
+
+  export class BTree {
+    constructor(order?: number);
+    insert(key: unknown, value: unknown): void;
+    find(key: unknown): unknown;
+    range(min: unknown, max: unknown): unknown[];
+  }
+
+  export class Cache {
+    constructor(options?: Record<string, unknown>);
+    get(key: string): unknown;
+    set(key: string, value: unknown, ttlMs?: number): void;
+    del(key: string): void;
+    flush(): void;
+    close(): void;
+  }
+
+  export class Plugin {
+    static create(plugin: JSQLPlugin): JSQLPlugin;
+  }
+
+  export class ModuleManager {
+    constructor(opts?: { cwd?: string });
+    applyTo(engine: JSQL): void;
+  }
+
+  export class JSQL_Error extends Error {
+    code: number;
+    codeKey: string;
+    args: unknown[];
+  }
+
+  export const ErrorCodes: Record<string, { code: number; msg: string }>;
+
+  export class JSQLFormat {
+    constructor(db: unknown);
+    dump(): string;
+    load(dump: string): void;
+  }
+
+  export class Datastore {
+    constructor(options?: DatabaseOptions);
+    insert(docs: unknown): Promise<unknown>;
+    find(query?: unknown): Promise<unknown[]>;
+    update(query: unknown, update: unknown): Promise<number>;
+    remove(query: unknown): Promise<number>;
+    loadDatabase(): Promise<void>;
+    persistence: { persistCachedDatabase: (cb?: (err?: Error) => void) => void };
+  }
+}
+
+export = JSQLNeo;

package/index.js

@@ -19,6 +19,9 @@ const sql = require('./lib/sql');
 const { Datastore } = require('./lib/nedb_compat');
 const mysqlCompat = require('./lib/mysql_compat');
 const { createMysqlServer, MysqlServer } = require('./lib/mysql_server');
+const migrate = require('./lib/migrate');
+const { WebUI } = require('./lib/web_ui');
+const { RedisServer, createRedisServer } = require('./lib/redis_server');
 
 module.exports = {
     JSQL: WasmClient.JSQL,
@@ -44,4 +47,19 @@ module.exports = {
     mysql: mysqlCompat,
     createMysqlServer,
     MysqlServer,
+    // 迁移工具: mysqldump 导入 / JSON / CSV
+    migrate,
+    exportTableToJSON: migrate.exportTableToJSON,
+    exportAllToJSON: migrate.exportAllToJSON,
+    importFromJSON: migrate.importFromJSON,
+    exportTableToCSV: migrate.exportTableToCSV,
+    importFromCSV: migrate.importFromCSV,
+    importDump: migrate.importDump,
+    importDumpFile: migrate.importDumpFile,
+    exportToFile: migrate.exportToFile,
+    // Web UI
+    WebUI,
+    // Redis 兼容服务器
+    RedisServer,
+    createRedisServer,
 };