@crvouga/mockingbird-service-redis 0.1.0

package/dist/server.d.ts

@@ -0,0 +1,266 @@
+interface RedisClock {
+    now(): number;
+    advance(ms: number): void;
+    subscribe(listener: () => void): () => void;
+    readonly manual: boolean;
+}
+
+type Reply = {
+    t: "simple";
+    v: string;
+} | {
+    t: "error";
+    v: string;
+} | {
+    t: "int";
+    v: number | bigint;
+} | {
+    t: "bulk";
+    v: Uint8Array | null;
+} | {
+    t: "array";
+    v: Reply[] | null;
+} | {
+    t: "null";
+} | {
+    t: "bool";
+    v: boolean;
+} | {
+    t: "double";
+    v: number;
+} | {
+    t: "map";
+    v: Array<[Reply, Reply]>;
+} | {
+    t: "push";
+    v: Reply[];
+};
+
+interface RedisUser {
+    name: string;
+    password: string;
+    readOnly?: boolean;
+}
+interface RedisOptions {
+    clock?: RedisClock;
+    databases?: number;
+    password?: string;
+    users?: RedisUser[];
+    maxmemory?: number;
+    maxmemoryPolicy?: "noeviction" | "allkeys-lru";
+    seed?: number;
+}
+type RedisFault = "readonly" | "oom" | "busy" | "disconnect" | "timeout" | {
+    latencyMs: number;
+} | null;
+interface Session {
+    id: number;
+    db: number;
+    protocol: 2 | 3;
+    name: string;
+    libName: string;
+    libVer: string;
+    authenticated: boolean;
+    username: string;
+    readOnly: boolean;
+    multi: Array<{
+        name: string;
+        args: Uint8Array[];
+    }> | null;
+    multiFailed: boolean;
+    watching: Array<{
+        db: number;
+        key: string;
+        gen: number;
+    }>;
+    channels: Set<string>;
+    patterns: Set<string>;
+    dead: boolean;
+    quit: boolean;
+    inExec: boolean;
+    onPush: (reply: Reply) => void;
+}
+declare class Redis {
+    readonly clock: RedisClock;
+    private readonly dbs;
+    private readonly password;
+    private readonly users;
+    private readonly authRequired;
+    readonly maxmemory: number;
+    private policy;
+    private rngState;
+    private faultValue;
+    private tail;
+    private sessions;
+    private nextClientId;
+    private waiters;
+    private channelSubs;
+    private patternSubs;
+    private scripts;
+    private invoked;
+    private scriptDepth;
+    private commandCount;
+    private closed;
+    consumersPaused: boolean;
+    private readonly disconnectListeners;
+    constructor(options?: RedisOptions);
+    client(): RedisClient;
+    advance(ms: number): void;
+    fault(value: RedisFault): void;
+    pauseConsumers(paused?: boolean): void;
+    waiterCount(): number;
+    inspect(db?: number): Array<{
+        key: string;
+        type: string;
+        pttl: number;
+    }>;
+    reset(): void;
+    close(): void;
+    onDisconnect(listener: (session: Session) => void): () => void;
+    createSession(): Session;
+    perform(session: Session, name: string, args: Uint8Array[]): Promise<Reply>;
+    private enqueue;
+    private applyLatency;
+    private dropSession;
+    private sessionOf;
+    private database;
+    private random;
+    private memory;
+    private dispatch;
+    private execCmd;
+    private guardWrite;
+    private cmdPing;
+    private cmdAuth;
+    private cmdHello;
+    private cmdSelect;
+    private cmdReset;
+    private cmdClient;
+    private clientInfo;
+    private info;
+    private keyspaceLines;
+    private cmdTime;
+    private cmdConfig;
+    private cmdRandomKey;
+    private cmdScan;
+    private cmdKeys;
+    private cmdType;
+    private cmdExists;
+    private cmdDel;
+    private cmdRename;
+    private cmdExpire;
+    private cmdTtl;
+    private cmdPersist;
+    private stringAt;
+    private cmdGet;
+    private cmdSet;
+    private cmdMget;
+    private cmdMset;
+    private cmdAppend;
+    private cmdStrlen;
+    private cmdGetRange;
+    private cmdSetRange;
+    private cmdIncr;
+    private cmdIncrBy;
+    private addInteger;
+    private cmdIncrByFloat;
+    private cmdGetDel;
+    private cmdGetEx;
+    private requireHash;
+    private cmdHash;
+    private requireList;
+    private cmdList;
+    private cmdBlockingList;
+    private takeList;
+    private requireSet;
+    private cmdSetFamily;
+    private requireZset;
+    private cmdZset;
+    private cmdZadd;
+    private cmdZrange;
+    private cmdBlockingZset;
+    private takeZset;
+    private cmdStream;
+    private stream;
+    private cmdXadd;
+    private nextId;
+    private cmdXrange;
+    private cmdXdel;
+    private cmdXtrim;
+    private cmdXgroup;
+    private cmdXread;
+    private readStreams;
+    private cmdXack;
+    private cmdXpending;
+    private cmdXclaim;
+    private cmdXinfo;
+    private cmdSub;
+    private cmdPublish;
+    private cmdPubsub;
+    private cmdExec;
+    private cmdDiscard;
+    private cmdWatch;
+    private cmdEval;
+    private cmdScript;
+    private runScript;
+    private luaDispatch;
+    private block;
+    private wake;
+    private wakeAll;
+    private satisfy;
+    private finishWaiter;
+    private failWaiter;
+    private leavePubsub;
+}
+declare class RedisClient {
+    private readonly redis;
+    private readonly session;
+    constructor(redis: Redis, session: Session);
+    get protocol(): 2 | 3;
+    onPush(listener: (reply: Reply) => void): void;
+    call(command: string, ...args: Array<string | number | Uint8Array>): Promise<unknown>;
+    raw(command: string, ...args: Array<string | number | Uint8Array>): Promise<Reply>;
+    pipeline(): RedisPipeline;
+    quit(): Promise<string>;
+}
+declare class RedisPipeline {
+    private readonly client;
+    private readonly commands;
+    constructor(client: RedisClient);
+    call(name: string, ...args: Array<string | number | Uint8Array>): this;
+    exec(): Promise<unknown[]>;
+}
+
+/** HTTP port for `serve --config`. The RESP socket binds an ephemeral port. */
+declare const DEFAULT_PORT = 8827;
+interface ServeOptions {
+    port?: number;
+    host?: string;
+}
+interface RedisListening {
+    host: string;
+    port: number;
+    close(): Promise<void>;
+}
+declare function serve(redis: Redis, options?: ServeOptions): Promise<RedisListening>;
+type FleetRuntime = {
+    fetch(request: Request): Promise<Response>;
+    respPort: number;
+    close(): Promise<void>;
+};
+type HttpListening = {
+    close(): Promise<void>;
+};
+/**
+ * Fleet entry for `serve --config`. HTTP `GET /health` reports `service: redis`.
+ * RESP listens on an ephemeral port named in the startup banner.
+ */
+declare const serveTarget: {
+    name: string;
+    defaultPort: number;
+    create(): Promise<FleetRuntime>;
+    listening(http: HttpListening): void;
+    banner(runtime: FleetRuntime): string[];
+};
+
+export { DEFAULT_PORT, serve, serveTarget };
+export type { RedisListening, ServeOptions };

package/dist/server.js

@@ -0,0 +1,12 @@
+import {
+  DEFAULT_PORT,
+  serve,
+  serveTarget
+} from "./chunk-7U5RQF7K.js";
+import "./chunk-4HDEOTYJ.js";
+export {
+  DEFAULT_PORT,
+  serve,
+  serveTarget
+};
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@crvouga/mockingbird-service-redis",
+  "version": "0.1.0",
+  "description": "In-process Redis RESP server for tests: strings, hashes, lists, sets, sorted sets, streams, transactions, pub/sub, and a Lua subset, with an injected clock. Not an HTTP mock.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "SUPPORT.md"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    }
+  },
+  "bin": {
+    "mockingbird-redis": "./dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/crvouga/mockingbird.git",
+    "directory": "packages/service/redis"
+  },
+  "homepage": "https://github.com/crvouga/mockingbird/tree/main/packages/service/redis#readme",
+  "keywords": [
+    "mockingbird",
+    "redis",
+    "resp",
+    "mock"
+  ],
+  "mockingbird": {
+    "runtime": "portable",
+    "entries": {
+      "server": "node",
+      "cli": "node"
+    },
+    "layer": "service",
+    "category": "databases",
+    "displayName": "Redis",
+    "status": "wip",
+    "vendor": {
+      "website": "https://redis.io",
+      "docs": "https://redis.io/docs/latest/commands/",
+      "icon": "redis",
+      "color": "#FF4438"
+    },
+    "parity": "RESP replies, expiration, transactions, and streams",
+    "parityTier": "cold"
+  },
+  "scripts": {
+    "build": "bun ../../../scripts/bundle-service.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "biome check .",
+    "test": "bun test",
+    "parity": "bun scripts/parity.ts",
+    "portability": "bun ../../../scripts/portability.ts",
+    "pack:check": "bun ../../../scripts/pack-check.ts"
+  },
+  "devDependencies": {
+    "@crvouga/mockingbird-credentials": "0.0.0-development",
+    "ioredis": "5.11.1"
+  }
+}