js-redis-server 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,347 @@
+import { Server } from 'net';
+import { LuaWasmModule, ReplyValue } from 'lua-redis-wasm';
+import { EventEmitter } from 'node:events';
+
+/**
+ * Redis command metadata following Redis COMMAND specification
+ * @see https://redis.io/commands/command
+ */
+interface CommandMetadata {
+    /** Command name (lowercase) */
+    name: string;
+    /**
+     * Number of arguments
+     * Positive: exact count (including command name)
+     * Negative: minimum count (abs value), variable args
+     * Example: GET = 2 (GET key), MGET = -2 (MGET key [key ...])
+     */
+    arity: number;
+    /** Command flags */
+    flags: CommandFlags;
+    /**
+     * First key position (0-indexed in args, not including command name)
+     * -1 means no keys
+     */
+    firstKey: number;
+    /**
+     * Last key position
+     * -1 means last argument is key
+     * -2 means second-to-last, etc.
+     */
+    lastKey: number;
+    /**
+     * Step between keys (usually 1)
+     * Example: MGET has step 1, MSET has step 2 (key val key val)
+     */
+    keyStep: number;
+    /**
+     * Divisor for remaining args when lastKey=-1
+     * @see https://redis.io/docs/latest/develop/reference/key-specs/
+     * 0 or 1: no limit (all remaining args are keys)
+     * 2: half the remaining args are keys (e.g., MSET key val key val)
+     * 3: one-third are keys, etc.
+     */
+    limit: number;
+    /** Redis command categories */
+    categories: CommandCategory[];
+}
+/**
+ * Command flags following Redis specification
+ */
+interface CommandFlags {
+    /** Command doesn't modify data (safe for replicas) */
+    readonly?: boolean;
+    /** Command modifies data */
+    write?: boolean;
+    /** Deny command when used memory > maxmemory */
+    denyoom?: boolean;
+    /** Administrative command */
+    admin?: boolean;
+    /** Not allowed in Lua scripts */
+    noscript?: boolean;
+    /** Returns random/non-deterministic results */
+    random?: boolean;
+    /** Blocking operation (BLPOP, BRPOP, etc.) */
+    blocking?: boolean;
+    /** O(1) time complexity */
+    fast?: boolean;
+    /** Keys are not in fixed positions (requires key extraction) */
+    movablekeys?: boolean;
+    /** Transaction-related command */
+    transaction?: boolean;
+}
+/**
+ * Redis command categories
+ * @see https://redis.io/commands#command-categories
+ */
+declare enum CommandCategory {
+    STRING = "@string",
+    HASH = "@hash",
+    LIST = "@list",
+    SET = "@set",
+    ZSET = "@zset",
+    KEYS = "@keys",
+    GENERIC = "@generic",
+    SCRIPT = "@scripting",
+    SERVER = "@server",
+    CONNECTION = "@connection",
+    CLUSTER = "@cluster",
+    TRANSACTION = "@transactions",
+    PUBSUB = "@pubsub",
+    STREAM = "@stream"
+}
+
+declare class UserFacedError extends Error {
+    toLuaError(): {
+        err: Buffer;
+    };
+}
+declare class UnknownCommand extends UserFacedError {
+    constructor(cmdName: string | Buffer, args: Buffer[] | string[]);
+}
+
+interface DBCommandExecutor {
+    shutdown(): Promise<void>;
+}
+interface ExecutionContext {
+    execute(transport: Transport, rawCmd: Buffer, args: Buffer[], signal: AbortSignal): ExecutionContext;
+    shutdown(): Promise<void>;
+}
+type CommandResult = string | number | bigint | null | Buffer | UserFacedError | CommandResult[];
+interface Logger {
+    info(msg: unknown, metadata?: Record<string, unknown>): void;
+    error(msg: unknown, metadata?: Record<string, unknown>): void;
+}
+interface Command {
+    /** Command metadata (arity, flags, key positions) */
+    readonly metadata: CommandMetadata;
+    /**
+     * Extract keys from command arguments
+     * Used for cluster slot routing and WATCH tracking
+     */
+    getKeys(rawCmd: Buffer, args: Buffer[]): Buffer[];
+    /**
+     * Execute command
+     */
+    run(rawCmd: Buffer, args: Buffer[], signal: AbortSignal, transport: Transport): CommandResult | void;
+}
+type SlotRange = [number, number];
+type DiscoveryNode = {
+    host: string;
+    port: number;
+    slots: SlotRange[];
+    id: string;
+};
+interface ClusterCommanderFactory {
+    createCommander(mySelfId: string): DBCommandExecutor;
+    createReadOnlyCommander(mySelfId: string): DBCommandExecutor;
+    shutdown(): Promise<void>;
+}
+interface DiscoveryService {
+    getAll(): DiscoveryNode[];
+    isMaster(id: string): boolean;
+    getMaster(id: string): DiscoveryNode;
+    getById(id: string): DiscoveryNode;
+    getBySlot(slot: number): DiscoveryNode;
+}
+interface Transport {
+    write(responseData: CommandResult): void;
+    flush(options?: {
+        close?: boolean;
+    }): void;
+    closeAfterFlush(): void;
+}
+
+declare class Resp2Transport {
+    private readonly logger;
+    private readonly commandExecutor;
+    readonly server: Server;
+    constructor(logger: Logger, commandExecutor: DBCommandExecutor);
+    private handleConnection;
+    listen(port?: number): Promise<void>;
+    close(): Promise<void>;
+    getAddress(): string;
+}
+
+interface LuaCommandContext {
+    luaCommands?: Record<string, Command>;
+    signal: AbortSignal;
+}
+declare class LuaRuntime {
+    private readonly hostState;
+    private engine;
+    constructor(module: LuaWasmModule);
+    eval(script: Buffer, ctx: LuaCommandContext, sha: string): ReplyValue;
+    evalWithArgs(script: Buffer, keys: Buffer[], args: Buffer[], ctx: LuaCommandContext, sha: string): ReplyValue;
+    private runLuaCommand;
+}
+
+declare function createCustomCommander(logger: Logger): Promise<CustomCommanderFactory>;
+declare class CustomCommanderFactory {
+    private readonly logger;
+    private readonly luaRuntime;
+    private readonly db;
+    constructor(logger: Logger, luaRuntime: LuaRuntime);
+    shutdown(): Promise<void>;
+    createCommander(): DBCommandExecutor;
+}
+
+declare class HashDataType {
+    private readonly data;
+    constructor();
+    hset(field: Buffer, value: Buffer): number;
+    hget(field: Buffer): Buffer | null;
+    hdel(field: Buffer): number;
+    hexists(field: Buffer): boolean;
+    hgetall(): Buffer[];
+    hkeys(): Buffer[];
+    hvals(): Buffer[];
+    hlen(): number;
+    hmget(fields: Buffer[]): (Buffer | null)[];
+    hincrby(field: Buffer, increment: number): number;
+    hincrbyfloat(field: Buffer, increment: number): number;
+}
+
+declare class ListDataType {
+    private readonly data;
+    constructor();
+    lpush(value: Buffer): number;
+    rpush(value: Buffer): number;
+    lpop(): Buffer | null;
+    rpop(): Buffer | null;
+    llen(): number;
+    lindex(index: number): Buffer | null;
+    lrange(start: number, stop: number): Buffer[];
+    lset(index: number, value: Buffer): boolean;
+    lrem(count: number, value: Buffer): number;
+    ltrim(start: number, stop: number): void;
+}
+
+declare class SetDataType {
+    private readonly data;
+    constructor();
+    sadd(value: Buffer): number;
+    srem(value: Buffer): number;
+    sismember(value: Buffer): boolean;
+    smembers(): Buffer[];
+    scard(): number;
+    spop(): Buffer | null;
+    srandmember(count?: number): Buffer | Buffer[] | null;
+    sdiff(otherSets: SetDataType[]): Buffer[];
+    sinter(otherSets: SetDataType[]): Buffer[];
+    sunion(otherSets: SetDataType[]): Buffer[];
+    smove(destination: SetDataType, member: Buffer): boolean;
+}
+
+declare class StreamDataType {
+}
+
+declare class StringDataType {
+    readonly data: Buffer;
+    constructor(data: Buffer);
+}
+
+declare class SortedSetDataType {
+    private readonly memberToScore;
+    private readonly scoreToMembers;
+    zadd(score: number, member: Buffer): number;
+    zrem(member: Buffer): number;
+    zscore(member: Buffer): number | null;
+    zcard(): number;
+    zrange(start: number, stop: number, withScores?: boolean): Buffer[];
+    zrevrange(start: number, stop: number, withScores?: boolean): Buffer[];
+    zincrby(member: Buffer, increment: number): number;
+    zrank(member: Buffer): number | null;
+    zrevrank(member: Buffer): number | null;
+    zrangebyscore(min: number, max: number): Buffer[];
+    zremrangebyscore(min: number, max: number): number;
+    private getSortedMembers;
+}
+
+type DataTypes = HashDataType | ListDataType | SetDataType | StreamDataType | StringDataType | SortedSetDataType;
+/**
+ * Store event types emitted by the reactive data store
+ */
+type StoreEvent = {
+    type: 'set';
+    key: Buffer;
+    value: DataTypes;
+} | {
+    type: 'del';
+    key: Buffer;
+} | {
+    type: 'expire';
+    key: Buffer;
+    expiration: number;
+} | {
+    type: 'evict';
+    key: Buffer;
+} | {
+    type: 'flush';
+};
+/**
+ * Event names emitted by the store:
+ * - 'change': Emitted on every mutation with StoreEvent payload
+ * - 'key:<keyString>': Emitted for key-specific changes (for WATCH)
+ */
+interface StoreEvents {
+    change: [event: StoreEvent];
+    [key: `key:${string}`]: [event: StoreEvent];
+}
+declare class DB extends EventEmitter<StoreEvents> {
+    private readonly mapping;
+    private readonly timings;
+    private readonly data;
+    private readonly scriptsStore;
+    constructor();
+    tryEvict(key: Buffer): boolean;
+    get(rawKey: Buffer): DataTypes | null;
+    set(rawKey: Buffer, val: DataTypes, expiration?: number): void;
+    del(rawKey: Buffer): boolean;
+    addScript(script: Buffer): string;
+    getScript(sha: string): Buffer | undefined;
+    flushScripts(): void;
+    getTtl(rawKey: Buffer): number;
+    setExpiration(rawKey: Buffer, expiration: number): boolean;
+    /**
+     * Remove all keys from the current database
+     */
+    flushdb(): void;
+    /**
+     * Remove all keys from all databases (same as flushdb in single-database implementation)
+     */
+    flushall(): void;
+    /**
+     * Get the number of keys in the current database
+     * This excludes expired keys
+     */
+    size(): number;
+}
+
+declare function createCustomClusterCommander(logger: Logger, discoveryService: DiscoveryService): Promise<ClusterCommanderFactory>;
+
+declare function computeSlotRange(index: number, masters: number): SlotRange;
+declare class ClusterNetwork implements DiscoveryService {
+    private readonly logger;
+    private readonly slotMapping;
+    private readonly transports;
+    private commanderFactory?;
+    constructor(logger: Logger);
+    private resolveAddress;
+    private createMasterId;
+    private createReplicaId;
+    getMaster(id: string): DiscoveryNode;
+    isMaster(id: string): boolean;
+    getById(id: string): DiscoveryNode;
+    getAll(): DiscoveryNode[];
+    getBySlot(slot: number): DiscoveryNode;
+    init(params: {
+        masters: number;
+        slaves: number;
+        basePort?: number;
+    }): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+export { ClusterNetwork, CustomCommanderFactory, DB, Resp2Transport, UnknownCommand, UserFacedError, computeSlotRange, createCustomClusterCommander, createCustomCommander };
+export type { ClusterCommanderFactory, Command, CommandResult, DBCommandExecutor, DiscoveryNode, DiscoveryService, ExecutionContext, Logger, SlotRange, Transport };

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,OAAO,EACP,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,MAAM,EACN,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,uBAAuB,EACvB,SAAS,GACV,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAG9D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAGxD,OAAO,EACL,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,4BAA4B,EAAE,MAAM,sCAAsC,CAAA;AAGnF,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAGzE,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAA"}