@crvouga/mockingbird-service-redis 2.12.0 → 2.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -1,4 +1,4 @@
1
- import "./chunk-BIMEYU5A.js";
1
+ import "./chunk-22CTWFCU.js";
2
2
  import {
3
3
  Redis,
4
4
  RedisClient,
@@ -6,10 +6,12 @@ import {
6
6
  RedisPipeline,
7
7
  RedisReplyError,
8
8
  createRedis,
9
- encodeReply,
10
9
  manualClock,
11
10
  wallClock
12
- } from "./chunk-TVELGGZ4.js";
11
+ } from "./chunk-AMGKTUAB.js";
12
+ import {
13
+ encodeReply
14
+ } from "./chunk-PJCRB2CA.js";
13
15
  export {
14
16
  Redis,
15
17
  RedisClient,
package/dist/server.d.ts CHANGED
@@ -1,3 +1,7 @@
1
+ import { Redis } from './index.js';
2
+ import { RespServerOptions } from './transport.js';
3
+ export { ByteStreamPair, ClientStream, DuplexLike, RespServer, createRespServer } from './transport.js';
4
+
1
5
  /**
2
6
  * The single source of time for a service.
3
7
  *
@@ -340,307 +344,11 @@ type ConfigService = {
340
344
  options?: Record<string, string | boolean>;
341
345
  };
342
346
 
343
- interface RedisClock {
344
- now(): number;
345
- advance(ms: number): void;
346
- subscribe(listener: () => void): () => void;
347
- readonly manual: boolean;
348
- set(ms: number): void;
349
- freeze(): void;
350
- unfreeze(): void;
351
- reset(): void;
352
- state(): {
353
- now: number;
354
- frozen: boolean;
355
- offsetMs: number;
356
- };
357
- }
358
-
359
- type Reply = {
360
- t: "simple";
361
- v: string;
362
- } | {
363
- t: "error";
364
- v: string;
365
- } | {
366
- t: "int";
367
- v: number | bigint;
368
- } | {
369
- t: "bulk";
370
- v: Uint8Array | null;
371
- } | {
372
- t: "array";
373
- v: Reply[] | null;
374
- } | {
375
- t: "null";
376
- } | {
377
- t: "bool";
378
- v: boolean;
379
- } | {
380
- t: "double";
381
- v: number;
382
- } | {
383
- t: "map";
384
- v: Array<[Reply, Reply]>;
385
- } | {
386
- t: "push";
387
- v: Reply[];
388
- };
389
-
390
- interface RedisUser {
391
- name: string;
392
- password: string;
393
- readOnly?: boolean;
394
- }
395
- interface RedisOptions {
396
- clock?: RedisClock;
397
- databases?: number;
398
- password?: string;
399
- users?: RedisUser[];
400
- maxmemory?: number;
401
- maxmemoryPolicy?: "noeviction" | "allkeys-lru";
402
- seed?: number;
403
- }
404
- type RedisFault = "readonly" | "oom" | "busy" | "disconnect" | "timeout" | "noscript" | {
405
- latencyMs: number;
406
- } | null;
407
- interface Session {
408
- controlPrivileged?: boolean;
409
- id: number;
410
- db: number;
411
- protocol: 2 | 3;
412
- name: string;
413
- libName: string;
414
- libVer: string;
415
- authenticated: boolean;
416
- username: string;
417
- readOnly: boolean;
418
- multi: Array<{
419
- name: string;
420
- args: Uint8Array[];
421
- raw?: string;
422
- }> | null;
423
- multiFailed: boolean;
424
- watching: Array<{
425
- db: number;
426
- key: string;
427
- gen: number;
428
- }>;
429
- channels: Set<string>;
430
- patterns: Set<string>;
431
- dead: boolean;
432
- quit: boolean;
433
- inExec: boolean;
434
- /** Port of the RESP listener this session arrived on, for INFO and CLIENT INFO. */
435
- localPort?: number | undefined;
436
- /** `host:port` of the client socket, shown on the MONITOR stream. */
437
- remoteAddr?: string | undefined;
438
- /** True after MONITOR: the connection receives every command other clients run. */
439
- monitor?: boolean;
440
- onPush: (reply: Reply) => void;
441
- }
442
- declare class Redis {
443
- readonly clock: RedisClock;
444
- private readonly dbs;
445
- private readonly password;
446
- private readonly users;
447
- private readonly authRequired;
448
- readonly maxmemory: number;
449
- private policy;
450
- private rngState;
451
- private readonly initialRngState;
452
- private faultValue;
453
- private tail;
454
- private sessions;
455
- private nextClientId;
456
- private waiters;
457
- private channelSubs;
458
- private patternSubs;
459
- private scripts;
460
- private invoked;
461
- private scriptDepth;
462
- private commandCount;
463
- private readonly commandStats;
464
- private peakMemory;
465
- private startedAt;
466
- private closed;
467
- private controlPaused;
468
- private pendingCommands;
469
- private readonly pendingLatency;
470
- private readonly snapshots;
471
- consumersPaused: boolean;
472
- private readonly disconnectListeners;
473
- constructor(options?: RedisOptions);
474
- client(): RedisClient;
475
- advance(ms: number): void;
476
- fault(value: RedisFault): void;
477
- pauseConsumers(paused?: boolean): void;
478
- waiterCount(): number;
479
- connections(): number;
480
- pendingJobs(): number;
481
- activeCommands(): number;
482
- nextEvent(): number | undefined;
483
- settleTimers(): void;
484
- activeJobs(): number;
485
- fence(): () => void;
486
- snapshot(): object;
487
- exportSnapshot(handle: unknown): unknown;
488
- importSnapshot(document: unknown): object;
489
- restore(handle: unknown): void;
490
- disconnect(session: Session): void;
491
- inspect(db?: number): Array<{
492
- key: string;
493
- type: string;
494
- pttl: number;
495
- }>;
496
- reset(): void;
497
- close(): void;
498
- onDisconnect(listener: (session: Session) => void): () => void;
499
- createSession(): Session;
500
- perform(session: Session, name: string, args: Uint8Array[]): Promise<Reply>;
501
- private enqueue;
502
- private applyLatency;
503
- private dropSession;
504
- private sessionOf;
505
- private database;
506
- private random;
507
- private memory;
508
- private dispatch;
509
- /** What a MONITOR connection may not run: Redis treats it like a replica link. */
510
- private touchesKeyspace;
511
- /**
512
- * Runs one command and shows it to MONITOR connections. `raw` is the name as the client typed
513
- * it, which is what Redis prints. EVAL is shown before the script's own calls (origin `lua`);
514
- * everything else after it ran, so SELECT shows the new database. Commands Redis refuses
515
- * before running them (unknown, wrong arity, NOAUTH, queued in MULTI) are not shown.
516
- */
517
- private execCmd;
518
- private monitoring;
519
- private feedMonitors;
520
- private execCommand;
521
- private readonly extraHost;
522
- private aclUsers;
523
- private guardWrite;
524
- private cmdPing;
525
- private cmdAuth;
526
- private cmdHello;
527
- private cmdSelect;
528
- private cmdReset;
529
- private cmdClient;
530
- private clientInfo;
531
- /**
532
- * INFO. Sections and field names follow Redis 7.2; values the emulator has no process behind
533
- * (CPU time, RSS, system memory) are fixed nominal numbers so parsers get well-formed fields.
534
- */
535
- private info;
536
- private keyspaceLines;
537
- private cmdTime;
538
- private cmdConfig;
539
- private cmdRandomKey;
540
- private cmdScan;
541
- private cmdKeys;
542
- private cmdType;
543
- private cmdExists;
544
- private cmdDel;
545
- private cmdRename;
546
- private cmdExpire;
547
- private cmdTtl;
548
- private cmdPersist;
549
- private stringAt;
550
- private cmdGet;
551
- /**
552
- * SET and its aliases. `command` names the caller in the expire-time error, as Redis does.
553
- * Options are parsed first and the expiry is validated after, like Redis, so a bad
554
- * expiry is rejected before NX/XX are considered and leaves any existing value alone.
555
- */
556
- private cmdSet;
557
- private cmdSetnx;
558
- private cmdMget;
559
- private cmdMset;
560
- private cmdAppend;
561
- private cmdStrlen;
562
- private cmdGetRange;
563
- private cmdSetRange;
564
- private cmdIncr;
565
- private cmdIncrBy;
566
- private addInteger;
567
- private cmdIncrByFloat;
568
- private cmdGetDel;
569
- private cmdGetEx;
570
- private requireHash;
571
- private cmdHash;
572
- private requireList;
573
- private cmdList;
574
- private cmdBlockingList;
575
- private takeList;
576
- private requireSet;
577
- private cmdSetFamily;
578
- private requireZset;
579
- private cmdZset;
580
- private cmdZadd;
581
- private cmdZrange;
582
- private cmdBlockingZset;
583
- private takeZset;
584
- private cmdStream;
585
- private stream;
586
- private cmdXadd;
587
- private nextId;
588
- private cmdXrange;
589
- private cmdXdel;
590
- private cmdXtrim;
591
- private cmdXgroup;
592
- private cmdXread;
593
- private readStreams;
594
- private cmdXack;
595
- private cmdXpending;
596
- private cmdXclaim;
597
- private cmdXinfo;
598
- private cmdSub;
599
- private cmdPublish;
600
- private cmdPubsub;
601
- private cmdExec;
602
- private cmdDiscard;
603
- private cmdWatch;
604
- private cmdEval;
605
- private cmdScript;
606
- private runScript;
607
- /** `redis.call` (`raise`) and `redis.pcall`: run one command for the script and convert its reply. */
608
- private luaDispatch;
609
- private block;
610
- private wake;
611
- private wakeAll;
612
- private satisfy;
613
- private finishWaiter;
614
- private failWaiter;
615
- private leavePubsub;
616
- }
617
- declare class RedisClient {
618
- private readonly redis;
619
- private readonly session;
620
- constructor(redis: Redis, session: Session);
621
- get protocol(): 2 | 3;
622
- onPush(listener: (reply: Reply) => void): void;
623
- call(command: string, ...args: Array<string | number | Uint8Array>): Promise<unknown>;
624
- raw(command: string, ...args: Array<string | number | Uint8Array>): Promise<Reply>;
625
- pipeline(): RedisPipeline;
626
- quit(): Promise<string>;
627
- }
628
- declare class RedisPipeline {
629
- private readonly client;
630
- private readonly commands;
631
- constructor(client: RedisClient);
632
- call(name: string, ...args: Array<string | number | Uint8Array>): this;
633
- exec(): Promise<unknown[]>;
634
- }
635
-
636
347
  /** HTTP port for `serve --config`. The RESP socket binds an ephemeral port. */
637
348
  declare const DEFAULT_PORT = 8827;
638
- interface ServeOptions {
349
+ interface ServeOptions extends RespServerOptions {
639
350
  port?: number;
640
351
  host?: string;
641
- admit?: () => boolean;
642
- closeEngine?: boolean;
643
- controlPrivileged?: boolean;
644
352
  }
645
353
  interface RedisListening {
646
354
  readonly listening: boolean;
@@ -648,6 +356,10 @@ interface RedisListening {
648
356
  port: number;
649
357
  close(): Promise<void>;
650
358
  }
359
+ /**
360
+ * Listen for RESP clients over TCP. Each socket is handed to a {@link createRespServer} server;
361
+ * where no listener can run, use that server from `/transport` directly.
362
+ */
651
363
  declare function serve(redis: Redis, options?: ServeOptions): Promise<RedisListening>;
652
364
  type FleetRuntime = {
653
365
  fetch(request: Request): Promise<Response>;
@@ -671,5 +383,5 @@ declare const serveTarget: {
671
383
  /** Each fleet namespace owns a listener and an engine; Redis SELECT retains vendor semantics. */
672
384
  declare function startProtocol(entry: ConfigService): Promise<FleetChild>;
673
385
 
674
- export { DEFAULT_PORT, serve, serveTarget };
386
+ export { DEFAULT_PORT, RespServerOptions, serve, serveTarget };
675
387
  export type { RedisListening, ServeOptions };
package/dist/server.js CHANGED
@@ -2,10 +2,15 @@ import {
2
2
  DEFAULT_PORT,
3
3
  serve,
4
4
  serveTarget
5
- } from "./chunk-TNRSFAUM.js";
6
- import "./chunk-TVELGGZ4.js";
5
+ } from "./chunk-CXFQFJZ3.js";
6
+ import "./chunk-AMGKTUAB.js";
7
+ import {
8
+ createRespServer
9
+ } from "./chunk-UO4RZQ54.js";
10
+ import "./chunk-PJCRB2CA.js";
7
11
  export {
8
12
  DEFAULT_PORT,
13
+ createRespServer,
9
14
  serve,
10
15
  serveTarget
11
16
  };
@@ -0,0 +1,77 @@
1
+ import { Redis } from './index.js';
2
+
3
+ /**
4
+ * The client connection a listener-free server accepts. The same shape is used by
5
+ * `@crvouga/mockingbird-service-postgres/transport`, so one in-memory or worker transport serves both.
6
+ *
7
+ * No `node:` import here: this file is part of the browser-safe `/transport` entry.
8
+ *
9
+ * @module
10
+ */
11
+ /**
12
+ * One client connection as a pair of web byte streams: what a WebSocket bridge, a `MessagePort`
13
+ * bridge, a Deno / Bun / Cloudflare socket or a unit test can hand over.
14
+ */
15
+ type ByteStreamPair = {
16
+ /** Bytes from the client to the server. Its end (`done`) is the client hanging up. */
17
+ readable: ReadableStream<Uint8Array>;
18
+ /** Bytes from the server to the client, written in the order the server produced them. */
19
+ writable: WritableStream<Uint8Array>;
20
+ };
21
+ /** The part of a Node `Duplex` (a `net.Socket`, a `tls.TLSSocket`, …) a server uses. */
22
+ interface DuplexLike {
23
+ on(event: string, listener: (...args: never[]) => void): unknown;
24
+ write(chunk: Uint8Array): unknown;
25
+ end(): unknown;
26
+ destroy(): unknown;
27
+ }
28
+ /** One accepted client connection: web streams, or a Node `Duplex`. */
29
+ type ClientStream = ByteStreamPair | DuplexLike;
30
+
31
+ /**
32
+ * The RESP server without a listener: it accepts client connections handed to it as byte
33
+ * streams, so it runs in a browser, a (Shared)Worker, an edge runtime or a unit test with no
34
+ * port. `serve()` from `/server` is this server behind `net.createServer`.
35
+ *
36
+ * Nothing here imports a `node:` built-in.
37
+ *
38
+ * @example
39
+ * ```ts
40
+ * import { createRedis } from "@crvouga/mockingbird-service-redis"
41
+ * import { createRespServer } from "@crvouga/mockingbird-service-redis/transport"
42
+ *
43
+ * const server = createRespServer(createRedis())
44
+ * const toServer = new TransformStream<Uint8Array, Uint8Array>()
45
+ * const toClient = new TransformStream<Uint8Array, Uint8Array>()
46
+ * void server.accept({ readable: toServer.readable, writable: toClient.writable })
47
+ * // The client writes RESP to toServer.writable and reads replies from toClient.readable.
48
+ * ```
49
+ *
50
+ * @module
51
+ */
52
+
53
+ interface RespServerOptions {
54
+ /** Called for each new connection; `false` closes it before it is served. */
55
+ admit?: () => boolean;
56
+ /** Let the connection's session use test-control commands reserved for the host. */
57
+ controlPrivileged?: boolean;
58
+ /** `close()` also closes the engine. Default `true`. */
59
+ closeEngine?: boolean;
60
+ }
61
+ interface RespServer {
62
+ /**
63
+ * Serve one client connection: web streams (`{ readable, writable }`) or a Node `Duplex`.
64
+ * Resolves when the connection closes, from either side; its blocking waiters, `MULTI` state,
65
+ * subscriptions and `CLIENT` registration are then released as on a socket close.
66
+ */
67
+ accept(stream: ClientStream): Promise<void>;
68
+ /** Open connections right now. */
69
+ readonly connections: number;
70
+ /** Close every connection (and the engine, unless `closeEngine: false`). */
71
+ close(): Promise<void>;
72
+ }
73
+ /** Create a RESP server over `redis` that accepts connections from {@link RespServer.accept}. */
74
+ declare function createRespServer(redis: Redis, options?: RespServerOptions): RespServer;
75
+
76
+ export { createRespServer };
77
+ export type { ByteStreamPair, ClientStream, DuplexLike, RespServer, RespServerOptions };
@@ -0,0 +1,8 @@
1
+ import {
2
+ createRespServer
3
+ } from "./chunk-UO4RZQ54.js";
4
+ import "./chunk-PJCRB2CA.js";
5
+ export {
6
+ createRespServer
7
+ };
8
+ //# sourceMappingURL=transport.js.map
@@ -0,0 +1,7 @@
1
+ {
2
+ "version": 3,
3
+ "sources": [],
4
+ "sourcesContent": [],
5
+ "mappings": "",
6
+ "names": []
7
+ }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@crvouga/mockingbird-service-redis",
3
- "version": "2.12.0",
3
+ "version": "2.14.0",
4
4
  "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 emulator.",
5
5
  "license": "MIT",
6
6
  "type": "module",
@@ -21,6 +21,10 @@
21
21
  "./server": {
22
22
  "types": "./dist/server.d.ts",
23
23
  "default": "./dist/server.js"
24
+ },
25
+ "./transport": {
26
+ "types": "./dist/transport.d.ts",
27
+ "default": "./dist/transport.js"
24
28
  }
25
29
  },
26
30
  "bin": {
@@ -92,6 +96,7 @@
92
96
  "@crvouga/mockingbird-service": "0.0.0-development",
93
97
  "@crvouga/mockingbird-credentials": "0.0.0-development",
94
98
  "bullmq": "5.76.2",
99
+ "esbuild": "^0.28.2",
95
100
  "ioredis": "5.11.1",
96
101
  "ioredis-5-9": "npm:ioredis@5.9.2"
97
102
  }
@@ -1 +0,0 @@
1
- //# sourceMappingURL=chunk-BIMEYU5A.js.map