@nestjs-redis/streams-transporter 1.0.0-0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Saba Pochkhua
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,176 @@
+<div align="center">
+
+<img src="https://raw.githubusercontent.com/CSenshi/nestjs-redis/main/docs/images/logo.png" alt="NestJS Redis Toolkit Logo" width="200" height="200">
+
+# @nestjs-redis/streams-transporter
+
+Custom NestJS microservices transporter using Redis Streams with event and request/response patterns
+
+[![npm version](https://badge.fury.io/js/%40nestjs-redis%2Fstreams-transporter.svg)](https://www.npmjs.com/package/@nestjs-redis/streams-transporter)
+[![npm downloads](https://img.shields.io/npm/dm/@nestjs-redis/streams-transporter.svg)](https://www.npmjs.com/package/@nestjs-redis/streams-transporter)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/)
+[![NestJS](https://img.shields.io/badge/NestJS-9%2B-red.svg)](https://nestjs.com/) [![Redis](https://img.shields.io/badge/Redis-5+-red.svg)](https://redis.io/)
+
+</div>
+
+---
+
+## Features
+
+- **Redis Streams–based transport**: Events and requests stored as stream entries; replies written to per-client reply streams
+- **Event and request/response**: Fire-and-forget events (`dispatchEvent`) and request/response via `send()` with routing callbacks
+- **Consumer groups**: Server uses `XREADGROUP` + `XACK` for at-least-once delivery and horizontal scaling
+- **Configurable options**: Stream prefix, consumer group/name, block timeout, batch size, max stream length (MAXLEN trim), retry delay
+- **NestJS integration**: `RedisStreamsContext` (stream name, message id, consumer group/name) passed to handlers; optional `onProcessingStartHook` / `onProcessingEndHook`
+- **Type-safe**: Event/request/response type guards and resolved options
+
+## Installation
+
+```bash
+npm install @nestjs-redis/streams-transporter redis
+```
+
+## Quick Start
+
+### Server (microservice)
+
+```typescript
+// main.ts
+import { NestFactory } from '@nestjs/core';
+import { MicroserviceOptions } from '@nestjs/microservices';
+import { RedisStreamServer } from '@nestjs-redis/streams-transporter';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
+    AppModule,
+    {
+      strategy: new RedisStreamServer({
+        url: 'redis://localhost:6379',
+        streamPrefix: '_microservices',
+        consumerGroup: 'nestjs-streams',
+        consumerName: 'my-consumer',
+      }),
+    },
+  );
+
+  await app.listen();
+}
+bootstrap();
+```
+
+### Client (hybrid app or separate service)
+
+```typescript
+// app.module.ts
+import { Module } from '@nestjs/common';
+import { ClientsModule, Transport } from '@nestjs/microservices';
+import { RedisStreamClient } from '@nestjs-redis/streams-transporter';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+@Module({
+  imports: [
+    ClientsModule.register([
+      {
+        name: 'STREAMS_SERVICE',
+        customClass: RedisStreamClient,
+        options: {
+          url: 'redis://localhost:6379',
+          streamPrefix: '_microservices',
+        },
+      },
+    ]),
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+```
+
+```typescript
+// app.controller.ts
+import { Controller, Get, Inject } from '@nestjs/common';
+import { ClientProxy } from '@nestjs/microservices';
+import { firstValueFrom } from 'rxjs';
+
+@Controller()
+export class AppController {
+  constructor(
+    @Inject('STREAMS_SERVICE') private readonly client: ClientProxy,
+  ) {}
+
+  @Get('echo')
+  async echo() {
+    return firstValueFrom(this.client.send('user.echo', { hello: 'world' }));
+  }
+}
+```
+
+### Event handlers (server)
+
+```typescript
+// app.controller.ts
+import { Controller } from '@nestjs/common';
+import { EventPattern, MessagePattern, Payload } from '@nestjs/microservices';
+import { Ctx } from '@nestjs/microservices';
+import { RedisStreamsContext } from '@nestjs-redis/streams-transporter';
+
+@Controller()
+export class AppController {
+  @MessagePattern('user.echo')
+  echo(@Payload() data: object, @Ctx() ctx: RedisStreamsContext) {
+    return { ok: true, data };
+  }
+
+  @EventPattern('user.created')
+  onUserCreated(@Payload() data: object, @Ctx() ctx: RedisStreamsContext) {
+    // fire-and-forget; no reply
+    console.log('User created', data, ctx.getStreamName(), ctx.getMessageId());
+  }
+}
+```
+
+## Options
+
+`RedisStreamServer` and `RedisStreamClient` accept `RedisStreamsOptions`, which extends Redis client options and adds:
+
+| Option            | Default                               | Description                                                               |
+| ----------------- | ------------------------------------- | ------------------------------------------------------------------------- |
+| `streamPrefix`    | `'_microservices'`                    | Prefix for request streams (e.g. `{prefix}:user.echo`) and reply streams. |
+| `consumerGroup`   | `'nestjs-streams'`                    | Consumer group name for server `XREADGROUP`.                              |
+| `consumerName`    | `''` (then `consumer-${process.pid}`) | Consumer name in the group.                                               |
+| `blockTimeout`    | `100`                                 | Block timeout (ms) for `XREAD` / `XREADGROUP`.                            |
+| `batchSize`       | `50`                                  | Max entries per read (`COUNT`).                                           |
+| `maxStreamLength` | `10000`                               | Max length for streams; `XADD ... TRIM MAXLEN ~` is used on add.          |
+| `retryDelay`      | `250`                                 | Delay (ms) before retrying after a read/connection error.                 |
+
+Use `resolveRedisStreamsOptions(options)` to get a fully resolved options object (all optional fields filled with defaults).
+
+## API
+
+- **`RedisStreamClient`** – NestJS `ClientProxy` implementation. Connects to Redis, publishes events/requests to streams, listens for replies on a dedicated reply stream and dispatches to `routingMap` callbacks. `close()` flushes callbacks with an error, deletes the reply stream, and quits the client.
+- **`RedisStreamServer`** – NestJS `CustomTransportStrategy`. Creates consumer groups, consumes via `XREADGROUP`, ACKs with `XACK`, invokes message/event handlers with `RedisStreamsContext`, and writes replies to the client’s reply stream.
+- **`RedisStreamsContext`** – Context passed to handlers (like Nest’s RPC context). Methods: `getStreamName()`, `getMessageId()`, `getConsumerGroup()`, `getConsumerName()`.
+- **`RedisStreamsOptions`** / **`RedisStreamsResolvedOptions`** – Options and resolved type; **`resolveRedisStreamsOptions(options)`** – returns resolved options.
+
+Stream entry shape:
+
+- **Events**: `e: '1'`, `data` (JSON).
+- **Requests**: `e: '0'`, `id`, `replyTo`, `data` (JSON).
+- **Responses**: `id`, `data` or `err` (JSON), `isDisposed: '1'`.
+
+## Links
+
+- Root repo: [CSenshi/nestjs-redis](https://github.com/CSenshi/nestjs-redis)
+- Issues: [GitHub Issues](https://github.com/CSenshi/nestjs-redis/issues)
+- Discussions: [GitHub Discussions](https://github.com/CSenshi/nestjs-redis/discussions)
+
+## Contributing
+
+Please see the [root contributing guidelines](https://github.com/CSenshi/nestjs-redis#contributing).
+
+## License
+
+MIT © [CSenshi](https://github.com/CSenshi)

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './lib/redis.events';
+export * from './lib/streams-transporter.client';
+export * from './lib/streams-transporter.context';
+export * from './lib/streams-transporter.options';
+export * from './lib/streams-transporter.server';
+export * from './lib/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,kCAAkC,CAAC;AACjD,cAAc,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./lib/redis.events"), exports);
+tslib_1.__exportStar(require("./lib/streams-transporter.client"), exports);
+tslib_1.__exportStar(require("./lib/streams-transporter.context"), exports);
+tslib_1.__exportStar(require("./lib/streams-transporter.options"), exports);
+tslib_1.__exportStar(require("./lib/streams-transporter.server"), exports);
+tslib_1.__exportStar(require("./lib/types"), exports);

package/dist/lib/redis.events.d.ts

@@ -0,0 +1,34 @@
+type VoidCallback = () => void;
+type OnErrorCallback = (error: Error) => void;
+type OnWarningCallback = (warning: any) => void;
+export declare const enum RedisStatus {
+    CONNECT = "connect",
+    DISCONNECTED = "disconnected",
+    RECONNECTING = "reconnecting",
+    CONNECTED = "connected"
+}
+export declare const enum RedisEventsMap {
+    CONNECT = "connect",
+    READY = "ready",
+    ERROR = "error",
+    CLOSE = "close",
+    RECONNECTING = "reconnecting",
+    END = "end",
+    WARNING = "warning"
+}
+/**
+ * Redis events map for the Redis client.
+ * Key is the event name and value is the corresponding callback function.
+ * @publicApi
+ */
+export type RedisEvents = {
+    connect: VoidCallback;
+    ready: VoidCallback;
+    error: OnErrorCallback;
+    close: VoidCallback;
+    reconnecting: VoidCallback;
+    end: VoidCallback;
+    warning: OnWarningCallback;
+};
+export {};
+//# sourceMappingURL=redis.events.d.ts.map

package/dist/lib/redis.events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.events.d.ts","sourceRoot":"","sources":["../../src/lib/redis.events.ts"],"names":[],"mappings":"AAAA,KAAK,YAAY,GAAG,MAAM,IAAI,CAAC;AAC/B,KAAK,eAAe,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;AAC9C,KAAK,iBAAiB,GAAG,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,CAAC;AAEhD,0BAAkB,WAAW;IAC3B,OAAO,YAAY;IACnB,YAAY,iBAAiB;IAC7B,YAAY,iBAAiB;IAC7B,SAAS,cAAc;CACxB;AAED,0BAAkB,cAAc;IAC9B,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,KAAK,UAAU;IACf,KAAK,UAAU;IACf,YAAY,iBAAiB;IAC7B,GAAG,QAAQ;IACX,OAAO,YAAY;CACpB;AACD;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,YAAY,CAAC;IACtB,KAAK,EAAE,YAAY,CAAC;IACpB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,YAAY,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;IAC3B,GAAG,EAAE,YAAY,CAAC;IAClB,OAAO,EAAE,iBAAiB,CAAC;CAC5B,CAAC;AACF,OAAO,EAAE,CAAC"}

package/dist/lib/redis.events.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisEventsMap = exports.RedisStatus = void 0;
+var RedisStatus;
+(function (RedisStatus) {
+    RedisStatus["CONNECT"] = "connect";
+    RedisStatus["DISCONNECTED"] = "disconnected";
+    RedisStatus["RECONNECTING"] = "reconnecting";
+    RedisStatus["CONNECTED"] = "connected";
+})(RedisStatus || (exports.RedisStatus = RedisStatus = {}));
+var RedisEventsMap;
+(function (RedisEventsMap) {
+    RedisEventsMap["CONNECT"] = "connect";
+    RedisEventsMap["READY"] = "ready";
+    RedisEventsMap["ERROR"] = "error";
+    RedisEventsMap["CLOSE"] = "close";
+    RedisEventsMap["RECONNECTING"] = "reconnecting";
+    RedisEventsMap["END"] = "end";
+    RedisEventsMap["WARNING"] = "warning";
+})(RedisEventsMap || (exports.RedisEventsMap = RedisEventsMap = {}));

package/dist/lib/streams-transporter.client.d.ts

@@ -0,0 +1,29 @@
+import { Logger } from '@nestjs/common';
+import { ClientProxy, ReadPacket, WritePacket } from '@nestjs/microservices';
+import { RedisClientType, createClient } from 'redis';
+import { type RedisEvents, RedisStatus } from './redis.events';
+import { RedisStreamsOptions } from './streams-transporter.options';
+export declare class RedisStreamClient extends ClientProxy<RedisEvents, RedisStatus> {
+    protected readonly logger: Logger;
+    private client;
+    protected connectionPromise: Promise<ReturnType<typeof createClient>> | null;
+    private readonly clientId;
+    private replyStreamName;
+    private isListening;
+    private replyListenerPromise;
+    private readonly options;
+    private pendingEventListeners;
+    constructor(options?: RedisStreamsOptions);
+    connect(): Promise<ReturnType<typeof createClient>>;
+    private registerEventListeners;
+    close(): Promise<void>;
+    dispatchEvent(packet: ReadPacket): Promise<any>;
+    publish(packet: ReadPacket, callback: (packet: WritePacket) => void): () => void;
+    getRequestPattern(pattern: string): string;
+    on<EventKey extends keyof RedisEvents = keyof RedisEvents, EventCallback extends RedisEvents[EventKey] = RedisEvents[EventKey]>(event: EventKey, callback: EventCallback): void;
+    private listenForReplies;
+    private handleReplyMessage;
+    private parseMessage;
+    unwrap<T = RedisClientType>(): T;
+}
+//# sourceMappingURL=streams-transporter.client.d.ts.map

package/dist/lib/streams-transporter.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams-transporter.client.d.ts","sourceRoot":"","sources":["../../src/lib/streams-transporter.client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAE7E,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AACtD,OAAO,EAAE,KAAK,WAAW,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EACL,mBAAmB,EAGpB,MAAM,+BAA+B,CAAC;AAIvC,qBAAa,iBAAkB,SAAQ,WAAW,CAAC,WAAW,EAAE,WAAW,CAAC;IAC1E,SAAS,CAAC,QAAQ,CAAC,MAAM,SAAsC;IAC/D,OAAO,CAAC,MAAM,CACP;IACP,SAAS,CAAC,iBAAiB,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,GAAG,IAAI,CACrE;IACP,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;IACrD,OAAO,CAAC,eAAe,CAAM;IAC7B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,oBAAoB,CAA8B;IAC1D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8B;IACtD,OAAO,CAAC,qBAAqB,CAGrB;gBAEI,OAAO,GAAE,mBAAwB;IAQvC,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;IAgBzD,OAAO,CAAC,sBAAsB;IA2BxB,KAAK;IAsBL,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC;IAuBrD,OAAO,CACL,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GACtC,MAAM,IAAI;IA6CN,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAIjC,EAAE,CAChB,QAAQ,SAAS,MAAM,WAAW,GAAG,MAAM,WAAW,EACtD,aAAa,SAAS,WAAW,CAAC,QAAQ,CAAC,GAAG,WAAW,CAAC,QAAQ,CAAC,EACnE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI;YAQnC,gBAAgB;IAiC9B,OAAO,CAAC,kBAAkB;IAwB1B,OAAO,CAAC,YAAY;IAQpB,MAAM,CAAC,CAAC,GAAG,eAAe,KAAK,CAAC;CASjC"}

package/dist/lib/streams-transporter.client.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStreamClient = void 0;
+const common_1 = require("@nestjs/common");
+const microservices_1 = require("@nestjs/microservices");
+const crypto_1 = require("crypto");
+const redis_1 = require("redis");
+const redis_events_1 = require("./redis.events");
+const streams_transporter_options_1 = require("./streams-transporter.options");
+const types_1 = require("./types");
+class RedisStreamClient extends microservices_1.ClientProxy {
+    constructor(options = {}) {
+        super();
+        this.logger = new common_1.Logger(RedisStreamClient.name);
+        this.client = null;
+        this.connectionPromise = null;
+        this.clientId = `client-${(0, crypto_1.randomUUID)()}`;
+        this.replyStreamName = '';
+        this.isListening = false;
+        this.replyListenerPromise = null;
+        this.pendingEventListeners = [];
+        this.options = (0, streams_transporter_options_1.resolveRedisStreamsOptions)(options);
+        this.replyStreamName = `${this.options.streamPrefix}:reply:${this.clientId}`;
+        this.initializeSerializer({});
+        this.initializeDeserializer({});
+    }
+    async connect() {
+        if (this.connectionPromise) {
+            return this.connectionPromise;
+        }
+        this.client = (0, redis_1.createClient)(this.options);
+        this.registerEventListeners();
+        this.connectionPromise = this.client.connect();
+        await this.connectionPromise;
+        this.isListening = true;
+        this.replyListenerPromise = this.listenForReplies();
+        return this.connectionPromise;
+    }
+    registerEventListeners() {
+        if (!this.client)
+            return;
+        this.client.on('error', (err) => this.logger.error(err));
+        this.client.on('connect', () => {
+            this._status$.next(redis_events_1.RedisStatus.CONNECT);
+        });
+        this.client.on('ready', () => {
+            this._status$.next(redis_events_1.RedisStatus.CONNECTED);
+        });
+        this.client.on('reconnecting', () => {
+            this._status$.next(redis_events_1.RedisStatus.RECONNECTING);
+        });
+        this.client.on('end', () => {
+            this._status$.next(redis_events_1.RedisStatus.DISCONNECTED);
+        });
+        if (this.pendingEventListeners.length > 0) {
+            this.pendingEventListeners.forEach(({ event, callback }) => {
+                if (!this.client)
+                    return;
+                this.client.on(event, callback);
+            });
+            this.pendingEventListeners = [];
+        }
+    }
+    async close() {
+        this.isListening = false;
+        if (this.replyListenerPromise) {
+            await this.replyListenerPromise;
+        }
+        if (this.client) {
+            for (const callback of this.routingMap.values()) {
+                callback({ err: new Error('Client closed'), isDisposed: true });
+            }
+            this.routingMap.clear();
+            try {
+                await this.client.del(this.replyStreamName);
+            }
+            catch {
+                // ignore
+            }
+            await this.client.quit();
+        }
+        this.client = null;
+        this.connectionPromise = null;
+        this.pendingEventListeners = [];
+    }
+    async dispatchEvent(packet) {
+        if (!this.client) {
+            throw new Error('Client not connected. Call connect() first.');
+        }
+        const pattern = this.normalizePattern(packet.pattern);
+        const streamName = this.getRequestPattern(pattern);
+        const serializedPacket = this.serializer.serialize(packet);
+        const data = {
+            e: '1',
+            data: JSON.stringify(serializedPacket.data),
+        };
+        await this.client.xAdd(streamName, '*', data, {
+            TRIM: {
+                strategy: 'MAXLEN',
+                strategyModifier: '~',
+                threshold: this.options.maxStreamLength,
+            },
+        });
+    }
+    publish(packet, callback) {
+        if (!this.client) {
+            throw new Error('Client not connected. Call connect() first.');
+        }
+        const requestPacket = this.assignPacketId(packet);
+        const cleanup = () => this.routingMap.delete(requestPacket.id);
+        try {
+            const pattern = this.normalizePattern(requestPacket.pattern);
+            const streamName = this.getRequestPattern(pattern);
+            const serializedPacket = this.serializer.serialize(requestPacket);
+            this.routingMap.set(requestPacket.id, callback);
+            void this.client
+                .xAdd(streamName, '*', {
+                e: '0',
+                id: requestPacket.id,
+                replyTo: this.replyStreamName,
+                data: JSON.stringify(serializedPacket.data),
+            }, {
+                TRIM: {
+                    strategy: 'MAXLEN',
+                    strategyModifier: '~',
+                    threshold: this.options.maxStreamLength,
+                },
+            })
+                .catch((err) => {
+                cleanup();
+                callback({ err });
+            });
+            return cleanup;
+        }
+        catch (err) {
+            callback({ err });
+            return () => void 0;
+        }
+    }
+    getRequestPattern(pattern) {
+        return `${this.options.streamPrefix}:${pattern}`;
+    }
+    on(event, callback) {
+        if (this.client) {
+            this.client.on(event, callback);
+        }
+        else {
+            this.pendingEventListeners.push({ event, callback });
+        }
+    }
+    async listenForReplies() {
+        if (!this.client)
+            return;
+        let lastId = '0';
+        while (this.isListening && this.client) {
+            try {
+                const result = await this.client.xRead({ key: this.replyStreamName, id: lastId }, { BLOCK: this.options.blockTimeout, COUNT: this.options.batchSize });
+                if (Array.isArray(result) && result.length > 0) {
+                    const streams = result;
+                    for (const streamData of streams) {
+                        for (const message of streamData.messages) {
+                            lastId = message.id;
+                            this.handleReplyMessage(message.message);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                if (this.isListening) {
+                    this.logger.error(err);
+                    await new Promise((resolve) => setTimeout(resolve, this.options.retryDelay));
+                }
+            }
+        }
+    }
+    handleReplyMessage(rawMessage) {
+        if (!(0, types_1.isResponsePacket)(rawMessage))
+            return;
+        const id = rawMessage.id;
+        const callback = this.routingMap.get(id);
+        if (!callback)
+            return;
+        if (rawMessage.err) {
+            this.routingMap.delete(id);
+            callback({ err: this.parseMessage(rawMessage.err) });
+            return;
+        }
+        const response = rawMessage.data !== undefined
+            ? this.parseMessage(rawMessage.data)
+            : undefined;
+        const isDisposed = rawMessage.isDisposed === '1';
+        callback({ response, isDisposed });
+        if (isDisposed) {
+            this.routingMap.delete(id);
+        }
+    }
+    parseMessage(content) {
+        try {
+            return JSON.parse(content);
+        }
+        catch {
+            return content;
+        }
+    }
+    unwrap() {
+        if (!this.client) {
+            throw new Error('Not initialized. Please call the "connect" method first.');
+        }
+        return this.client;
+    }
+}
+exports.RedisStreamClient = RedisStreamClient;

package/dist/lib/streams-transporter.context.d.ts

@@ -0,0 +1,14 @@
+import { BaseRpcContext } from '@nestjs/microservices';
+type RedisStreamsContextArgs = [string, string, string, string];
+/**
+ * @publicApi
+ */
+export declare class RedisStreamsContext extends BaseRpcContext<RedisStreamsContextArgs> {
+    constructor(args: RedisStreamsContextArgs);
+    getStreamName(): string;
+    getMessageId(): string;
+    getConsumerGroup(): string;
+    getConsumerName(): string;
+}
+export {};
+//# sourceMappingURL=streams-transporter.context.d.ts.map

package/dist/lib/streams-transporter.context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams-transporter.context.d.ts","sourceRoot":"","sources":["../../src/lib/streams-transporter.context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,KAAK,uBAAuB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAEhE;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,cAAc,CAAC,uBAAuB,CAAC;gBAClE,IAAI,EAAE,uBAAuB;IAIzC,aAAa;IAIb,YAAY;IAIZ,gBAAgB;IAIhB,eAAe;CAGhB"}

package/dist/lib/streams-transporter.context.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStreamsContext = void 0;
+const microservices_1 = require("@nestjs/microservices");
+/**
+ * @publicApi
+ */
+class RedisStreamsContext extends microservices_1.BaseRpcContext {
+    constructor(args) {
+        super(args);
+    }
+    getStreamName() {
+        return this.args[0];
+    }
+    getMessageId() {
+        return this.args[1];
+    }
+    getConsumerGroup() {
+        return this.args[2];
+    }
+    getConsumerName() {
+        return this.args[3];
+    }
+}
+exports.RedisStreamsContext = RedisStreamsContext;

package/dist/lib/streams-transporter.options.d.ts

@@ -0,0 +1,15 @@
+import type { RedisClientOptions } from 'redis';
+export interface RedisStreamsOptions extends RedisClientOptions {
+    streamPrefix?: string;
+    consumerGroup?: string;
+    consumerName?: string;
+    blockTimeout?: number;
+    batchSize?: number;
+    replyStreamTTL?: number;
+    maxStreamLength?: number;
+    retryDelay?: number;
+}
+export declare const REDIS_STREAMS_DEFAULT_OPTIONS: Required<Pick<RedisStreamsOptions, 'streamPrefix' | 'consumerGroup' | 'consumerName' | 'blockTimeout' | 'batchSize' | 'maxStreamLength' | 'retryDelay'>>;
+export type RedisStreamsResolvedOptions = RedisStreamsOptions & Required<Pick<RedisStreamsOptions, keyof typeof REDIS_STREAMS_DEFAULT_OPTIONS>>;
+export declare const resolveRedisStreamsOptions: (options?: RedisStreamsOptions) => RedisStreamsResolvedOptions;
+//# sourceMappingURL=streams-transporter.options.d.ts.map

package/dist/lib/streams-transporter.options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams-transporter.options.d.ts","sourceRoot":"","sources":["../../src/lib/streams-transporter.options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAEhD,MAAM,WAAW,mBAAoB,SAAQ,kBAAkB;IAC7D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAClD,IAAI,CACF,mBAAmB,EACjB,cAAc,GACd,eAAe,GACf,cAAc,GACd,cAAc,GACd,WAAW,GACX,iBAAiB,GACjB,YAAY,CACf,CASF,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,mBAAmB,GAC3D,QAAQ,CACN,IAAI,CAAC,mBAAmB,EAAE,MAAM,OAAO,6BAA6B,CAAC,CACtE,CAAC;AAEJ,eAAO,MAAM,0BAA0B,GACrC,UAAS,mBAAwB,KAChC,2BAeD,CAAC"}

package/dist/lib/streams-transporter.options.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRedisStreamsOptions = exports.REDIS_STREAMS_DEFAULT_OPTIONS = void 0;
+exports.REDIS_STREAMS_DEFAULT_OPTIONS = {
+    streamPrefix: '_microservices',
+    consumerGroup: 'nestjs-streams',
+    consumerName: '',
+    blockTimeout: 100,
+    batchSize: 50,
+    maxStreamLength: 10000,
+    retryDelay: 250,
+};
+const resolveRedisStreamsOptions = (options = {}) => ({
+    ...options,
+    ...exports.REDIS_STREAMS_DEFAULT_OPTIONS,
+    streamPrefix: options.streamPrefix ?? exports.REDIS_STREAMS_DEFAULT_OPTIONS.streamPrefix,
+    consumerGroup: options.consumerGroup ?? exports.REDIS_STREAMS_DEFAULT_OPTIONS.consumerGroup,
+    consumerName: options.consumerName ?? exports.REDIS_STREAMS_DEFAULT_OPTIONS.consumerName,
+    blockTimeout: options.blockTimeout ?? exports.REDIS_STREAMS_DEFAULT_OPTIONS.blockTimeout,
+    batchSize: options.batchSize ?? exports.REDIS_STREAMS_DEFAULT_OPTIONS.batchSize,
+    maxStreamLength: options.maxStreamLength ?? exports.REDIS_STREAMS_DEFAULT_OPTIONS.maxStreamLength,
+    retryDelay: options.retryDelay ?? exports.REDIS_STREAMS_DEFAULT_OPTIONS.retryDelay,
+});
+exports.resolveRedisStreamsOptions = resolveRedisStreamsOptions;

package/dist/lib/streams-transporter.server.d.ts

@@ -0,0 +1,46 @@
+import { CustomTransportStrategy, Server } from '@nestjs/microservices';
+import { type RedisClientType } from 'redis';
+import { RedisEvents, RedisStatus } from './redis.events';
+import { RedisStreamsOptions } from './streams-transporter.options';
+export declare class RedisStreamServer extends Server<RedisEvents, RedisStatus> implements CustomTransportStrategy {
+    private client;
+    private isConsuming;
+    private consumePromise;
+    private lastIds;
+    private consumerGroup;
+    private consumerName;
+    transportId: symbol;
+    private readonly options;
+    constructor(options?: RedisStreamsOptions);
+    connect(): Promise<void>;
+    private registerEventListeners;
+    /**
+     * Triggered on application shutdown.
+     */
+    close(): Promise<void>;
+    /**
+     * Triggered when you run "app.listen()".
+     */
+    listen(callback: (err?: unknown) => void): Promise<void>;
+    /**
+     * You can ignore this method if you don't want transporter users
+     * to be able to register event listeners. Most custom implementations
+     * will not need this.
+     */
+    on<EventKey extends keyof RedisEvents = keyof RedisEvents, EventCallback extends RedisEvents[EventKey] = RedisEvents[EventKey]>(event: EventKey, callback: EventCallback): void;
+    /**
+     * You can ignore this method if you don't want transporter users
+     * to be able to retrieve the underlying native server. Most custom implementations
+     * will not need this.
+     */
+    unwrap<T = RedisClientType>(): T;
+    private bindEvents;
+    private createConsumerGroup;
+    private consumeMessages;
+    private handleStreamMessage;
+    private acknowledgeMessage;
+    parseMessage(content: any): Record<string, any>;
+    getRequestPattern(pattern: string): string;
+    private handleRequest;
+}
+//# sourceMappingURL=streams-transporter.server.d.ts.map

package/dist/lib/streams-transporter.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams-transporter.server.d.ts","sourceRoot":"","sources":["../../src/lib/streams-transporter.server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACxE,OAAO,EAAE,KAAK,eAAe,EAAgB,MAAM,OAAO,CAAC;AAE3D,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE1D,OAAO,EACL,mBAAmB,EAGpB,MAAM,+BAA+B,CAAC;AAGvC,qBAAa,iBACX,SAAQ,MAAM,CAAC,WAAW,EAAE,WAAW,CACvC,YAAW,uBAAuB;IAElC,OAAO,CAAC,MAAM,CACP;IACP,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,cAAc,CAA8B;IACpD,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,aAAa,CAAM;IAC3B,OAAO,CAAC,YAAY,CAA6B;IACjC,WAAW,SAA2B;IACtD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8B;gBAE1C,OAAO,GAAE,mBAAwB;IASvC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAO9B,OAAO,CAAC,sBAAsB;IAmB9B;;OAEG;IACG,KAAK;IAUX;;OAEG;IACG,MAAM,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,IAAI;IAY9C;;;;OAIG;IACH,EAAE,CACA,QAAQ,SAAS,MAAM,WAAW,GAAG,MAAM,WAAW,EACtD,aAAa,SAAS,WAAW,CAAC,QAAQ,CAAC,GAAG,WAAW,CAAC,QAAQ,CAAC,EACnE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI;IAIjD;;;;OAIG;IACH,MAAM,CAAC,CAAC,GAAG,eAAe,KAAK,CAAC;YAUlB,UAAU;YAoBV,mBAAmB;YAanB,eAAe;YAuDf,mBAAmB;YAqCnB,kBAAkB;IAYzB,YAAY,CAAC,OAAO,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAQ/C,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;YAInC,aAAa;CA6D5B"}

package/dist/lib/streams-transporter.server.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStreamServer = void 0;
+const microservices_1 = require("@nestjs/microservices");
+const redis_1 = require("redis");
+const rxjs_1 = require("rxjs");
+const redis_events_1 = require("./redis.events");
+const streams_transporter_context_1 = require("./streams-transporter.context");
+const streams_transporter_options_1 = require("./streams-transporter.options");
+const types_1 = require("./types");
+class RedisStreamServer extends microservices_1.Server {
+    constructor(options = {}) {
+        super();
+        this.client = null;
+        this.isConsuming = false;
+        this.consumePromise = null;
+        this.lastIds = new Map();
+        this.consumerGroup = '';
+        this.consumerName = `consumer-${process.pid}`;
+        this.transportId = Symbol('REDIS_STREAMS');
+        this.options = (0, streams_transporter_options_1.resolveRedisStreamsOptions)(options);
+        this.consumerGroup = this.options.consumerGroup;
+        this.consumerName = this.options.consumerName || `consumer-${process.pid}`;
+        this.initializeSerializer({});
+        this.initializeDeserializer({});
+    }
+    async connect() {
+        this.client = (0, redis_1.createClient)(this.options);
+        this.registerEventListeners();
+        await this.client.connect();
+    }
+    registerEventListeners() {
+        if (!this.client)
+            return;
+        this.client.on('error', (err) => this.logger.error(err));
+        this.client.on('connect', () => {
+            this._status$.next(redis_events_1.RedisStatus.CONNECT);
+        });
+        this.client.on('ready', () => {
+            this._status$.next(redis_events_1.RedisStatus.CONNECTED);
+        });
+        this.client.on('reconnecting', () => {
+            this._status$.next(redis_events_1.RedisStatus.RECONNECTING);
+        });
+        this.client.on('end', () => {
+            this._status$.next(redis_events_1.RedisStatus.DISCONNECTED);
+        });
+    }
+    /**
+     * Triggered on application shutdown.
+     */
+    async close() {
+        this.isConsuming = false;
+        if (this.consumePromise) {
+            await this.consumePromise;
+        }
+        if (this.client)
+            await this.client.quit();
+        this.client = null;
+        this.lastIds.clear();
+    }
+    /**
+     * Triggered when you run "app.listen()".
+     */
+    async listen(callback) {
+        try {
+            if (!this.client) {
+                await this.connect();
+            }
+            await this.bindEvents();
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+    /**
+     * You can ignore this method if you don't want transporter users
+     * to be able to register event listeners. Most custom implementations
+     * will not need this.
+     */
+    on(event, callback) {
+        throw new Error('Method not implemented.' + event + callback);
+    }
+    /**
+     * You can ignore this method if you don't want transporter users
+     * to be able to retrieve the underlying native server. Most custom implementations
+     * will not need this.
+     */
+    unwrap() {
+        if (!this.client) {
+            throw new Error('Redis client is not initialized. Make sure to call "connect()" first.');
+        }
+        return this.client;
+    }
+    async bindEvents() {
+        const patterns = Array.from(this.messageHandlers.keys());
+        if (patterns.length === 0) {
+            return;
+        }
+        for (const pattern of patterns) {
+            const streamName = this.getRequestPattern(pattern);
+            if (!this.lastIds.has(streamName)) {
+                this.lastIds.set(streamName, '0');
+            }
+            await this.createConsumerGroup(streamName);
+        }
+        if (!this.isConsuming) {
+            this.isConsuming = true;
+            this.consumePromise = this.consumeMessages();
+        }
+    }
+    async createConsumerGroup(streamName) {
+        if (!this.client)
+            return;
+        try {
+            await this.client.xGroupCreate(streamName, this.consumerGroup, '$', {
+                MKSTREAM: true,
+            });
+        }
+        catch (error) {
+            if (!error?.message?.includes('BUSYGROUP')) {
+                throw error;
+            }
+        }
+    }
+    async consumeMessages() {
+        if (!this.client)
+            return;
+        while (this.isConsuming && this.client) {
+            const streams = Array.from(this.lastIds.keys()).map((key) => ({
+                key,
+                id: '>',
+            }));
+            if (streams.length === 0) {
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                continue;
+            }
+            try {
+                const result = (await this.client.xReadGroup(this.consumerGroup, this.consumerName, streams, {
+                    BLOCK: this.options.blockTimeout,
+                    COUNT: this.options.batchSize,
+                }));
+                if (!result) {
+                    continue;
+                }
+                for (const streamData of result) {
+                    for (const message of streamData.messages) {
+                        await this.handleStreamMessage(streamData.name, message.id, message.message);
+                    }
+                }
+            }
+            catch (error) {
+                if (this.isConsuming) {
+                    this.logger.error(error);
+                    await new Promise((resolve) => setTimeout(resolve, this.options.retryDelay));
+                }
+            }
+        }
+    }
+    async handleStreamMessage(streamName, messageId, rawMessage) {
+        try {
+            const pattern = streamName.replace(`${this.options.streamPrefix}:`, '');
+            const data = this.parseMessage(rawMessage.data);
+            const context = new streams_transporter_context_1.RedisStreamsContext([
+                streamName,
+                messageId,
+                this.consumerGroup,
+                this.consumerName,
+            ]);
+            if ((0, types_1.isRequestPacket)(rawMessage)) {
+                await this.handleRequest(pattern, data, rawMessage, context);
+                return;
+            }
+            if ((0, types_1.isEventPacket)(rawMessage)) {
+                this.onProcessingStartHook(this.transportId, context, async () => void 0);
+                try {
+                    await this.handleEvent(pattern, { pattern, data }, context);
+                }
+                finally {
+                    this.onProcessingEndHook?.(this.transportId, context);
+                }
+            }
+        }
+        finally {
+            await this.acknowledgeMessage(streamName, messageId);
+        }
+    }
+    async acknowledgeMessage(streamName, messageId) {
+        if (!this.client)
+            return;
+        try {
+            await this.client.xAck(streamName, this.consumerGroup, messageId);
+        }
+        catch (error) {
+            this.logger.error(error);
+        }
+    }
+    parseMessage(content) {
+        try {
+            return JSON.parse(content);
+        }
+        catch {
+            return content;
+        }
+    }
+    getRequestPattern(pattern) {
+        return `${this.options.streamPrefix}:${pattern}`;
+    }
+    async handleRequest(pattern, data, rawMessage, context) {
+        if (!this.client)
+            return;
+        const handler = this.getHandlerByPattern(pattern);
+        if (!handler)
+            return;
+        const replyTo = rawMessage.replyTo;
+        const id = rawMessage.id;
+        if (!replyTo || !id)
+            return;
+        this.onProcessingStartHook?.(this.transportId, context, async () => void 0);
+        try {
+            const response$ = this.transformToObservable(await handler(data, context));
+            const response = await (0, rxjs_1.firstValueFrom)(response$);
+            await this.client.xAdd(replyTo, '*', {
+                id,
+                data: JSON.stringify(response),
+                isDisposed: '1',
+            }, {
+                TRIM: {
+                    strategy: 'MAXLEN',
+                    strategyModifier: '~',
+                    threshold: this.options.maxStreamLength,
+                },
+            });
+        }
+        catch (error) {
+            await this.client.xAdd(replyTo, '*', {
+                id,
+                err: JSON.stringify(error instanceof Error
+                    ? { message: error.message, name: error.name }
+                    : error),
+                isDisposed: '1',
+            }, {
+                TRIM: {
+                    strategy: 'MAXLEN',
+                    strategyModifier: '~',
+                    threshold: this.options.maxStreamLength,
+                },
+            });
+        }
+        finally {
+            this.onProcessingEndHook?.(this.transportId, context);
+        }
+    }
+}
+exports.RedisStreamServer = RedisStreamServer;

package/dist/lib/types.d.ts

@@ -0,0 +1,21 @@
+export type EventType = {
+    e: '0' | '1';
+    data: string;
+};
+export type RequestType = {
+    e: '0' | '1';
+    data: string;
+    id: string;
+    replyTo: string;
+};
+export type ResponseType = {
+    id: string;
+    data?: string;
+    err?: string;
+    isDisposed?: '0' | '1';
+};
+export type RedisPacket = EventType | RequestType;
+export declare function isEventPacket(packet: Record<string, string>): packet is EventType;
+export declare function isRequestPacket(packet: Record<string, string>): packet is RequestType;
+export declare function isResponsePacket(packet: Record<string, string>): packet is ResponseType;
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG;IACtB,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,WAAW,CAAC;AAElD,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,MAAM,IAAI,SAAS,CAErB;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,MAAM,IAAI,WAAW,CAEvB;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,MAAM,IAAI,YAAY,CAExB"}

package/dist/lib/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEventPacket = isEventPacket;
+exports.isRequestPacket = isRequestPacket;
+exports.isResponsePacket = isResponsePacket;
+function isEventPacket(packet) {
+    return packet.e === '1';
+}
+function isRequestPacket(packet) {
+    return packet.e === '0';
+}
+function isResponsePacket(packet) {
+    return typeof packet.id === 'string' && 'isDisposed' in packet;
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@nestjs-redis/streams-transporter",
+  "version": "1.0.0-0",
+  "license": "MIT",
+  "author": "Saba Pochkhua <saba.pochkhua@gmail.com> (https://github.com/CSenshi)",
+  "description": "Redis Streams-based transporter for NestJS microservices, enabling message passing via Redis Streams",
+  "keywords": [
+    "nestjs",
+    "redis",
+    "streams",
+    "transporter",
+    "microservices",
+    "typescript",
+    "node-redis"
+  ],
+  "homepage": "https://github.com/CSenshi/nestjs-redis/tree/main/packages/streams-transporter",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CSenshi/nestjs-redis",
+    "directory": "packages/streams-transporter"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=8.0.0"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "nx": {
+    "name": "streams-transporter"
+  },
+  "dependencies": {
+    "@nestjs/microservices": "^11.1.12",
+    "redis": "^5.0.0",
+    "tslib": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^9.0.0 || ^10.0.0 || ^11.0.0"
+  }
+}