@nestjs-redisx/streams 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 NestJS RedisX Contributors
+
+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,56 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/nestjs-redisx/nestjs-redisx/main/website/public/images/logo.png" alt="NestJS RedisX" />
+</p>
+
+# @nestjs-redisx/streams
+
+[![npm](https://img.shields.io/npm/v/@nestjs-redisx/streams)](https://www.npmjs.com/package/@nestjs-redisx/streams)
+[![npm downloads](https://img.shields.io/npm/dm/@nestjs-redisx/streams)](https://www.npmjs.com/package/@nestjs-redisx/streams)
+[![license](https://img.shields.io/npm/l/@nestjs-redisx/streams)](https://opensource.org/licenses/MIT)
+
+Redis Streams plugin for NestJS RedisX. Provides `StreamProducerService` for publishing and `@StreamConsumer` decorator for declarative consumer groups with dead-letter queues and backpressure.
+
+## Installation
+
+```bash
+npm install @nestjs-redisx/core @nestjs-redisx/streams ioredis
+```
+
+## Quick Example
+
+```typescript
+import { RedisModule } from '@nestjs-redisx/core';
+import { StreamsPlugin, StreamConsumer, STREAM_PRODUCER, IStreamProducer } from '@nestjs-redisx/streams';
+
+@Module({
+  imports: [
+    RedisModule.forRoot({
+      clients: { host: 'localhost', port: 6379 },
+      plugins: [new StreamsPlugin({ consumer: { batchSize: 10 }, dlq: { enabled: true } })],
+    }),
+  ],
+})
+export class AppModule {}
+
+@Injectable()
+export class OrderService {
+  constructor(@Inject(STREAM_PRODUCER) private producer: IStreamProducer) {}
+  async create(order: Order) {
+    await this.producer.publish('orders', { orderId: order.id });
+  }
+}
+
+@Injectable()
+export class OrderProcessor {
+  @StreamConsumer({ stream: 'orders', group: 'processors' })
+  async handle(msg: { orderId: string }) { /* process */ }
+}
+```
+
+## Documentation
+
+Full documentation: [nestjs-redisx.dev/en/reference/streams/](https://nestjs-redisx.dev/en/reference/streams/)
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { StreamsPlugin } from './streams.plugin';
+export { StreamProducerService } from './streams/application/services/stream-producer.service';
+export { StreamConsumerService } from './streams/application/services/stream-consumer.service';
+export { DeadLetterService } from './streams/application/services/dead-letter.service';
+export type { IStreamProducer } from './streams/application/ports/stream-producer.port';
+export type { IStreamConsumer } from './streams/application/ports/stream-consumer.port';
+export type { IDeadLetterService } from './streams/application/ports/dead-letter.port';
+export { StreamMessage } from './streams/domain/entities/stream-message.entity';
+export { StreamConsumer, STREAM_CONSUMER_METADATA } from './streams/api/decorators/stream-consumer.decorator';
+export type { IStreamsPluginOptions, IStreamsPluginOptions as StreamsPluginOptions, IStreamMessage, PublishOptions, StreamInfo, ConsumeOptions, ConsumerHandle, PendingInfo, MessageHandler, DlqMessage, StreamConsumerOptions } from './shared/types';
+export { StreamError, StreamPublishError, StreamConsumeError, StreamGroupError } from './shared/errors';
+export { STREAM_PRODUCER, STREAM_CONSUMER, DEAD_LETTER_SERVICE, STREAMS_PLUGIN_OPTIONS } from './shared/constants';
+//# 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":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD,OAAO,EAAE,qBAAqB,EAAE,MAAM,wDAAwD,CAAC;AAC/F,OAAO,EAAE,qBAAqB,EAAE,MAAM,wDAAwD,CAAC;AAC/F,OAAO,EAAE,iBAAiB,EAAE,MAAM,oDAAoD,CAAC;AAGvF,YAAY,EAAE,eAAe,EAAE,MAAM,kDAAkD,CAAC;AACxF,YAAY,EAAE,eAAe,EAAE,MAAM,kDAAkD,CAAC;AACxF,YAAY,EAAE,kBAAkB,EAAE,MAAM,8CAA8C,CAAC;AAGvF,OAAO,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AAGhF,OAAO,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,oDAAoD,CAAC;AAG9G,YAAY,EAAE,qBAAqB,EAAE,qBAAqB,IAAI,oBAAoB,EAAE,cAAc,EAAE,cAAc,EAAE,UAAU,EAAE,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,cAAc,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAGvP,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGxG,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,596 @@
+'use strict';
+
+var os = require('os');
+var common = require('@nestjs/common');
+var core = require('@nestjs-redisx/core');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var os__namespace = /*#__PURE__*/_interopNamespace(os);
+
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/shared/constants/index.ts
+var STREAMS_PLUGIN_OPTIONS = /* @__PURE__ */ Symbol.for("STREAMS_PLUGIN_OPTIONS");
+var STREAM_PRODUCER = /* @__PURE__ */ Symbol.for("STREAM_PRODUCER");
+var STREAM_CONSUMER = /* @__PURE__ */ Symbol.for("STREAM_CONSUMER");
+var DEAD_LETTER_SERVICE = /* @__PURE__ */ Symbol.for("DEAD_LETTER_SERVICE");
+var STREAM_CONSUMER_METADATA = /* @__PURE__ */ Symbol.for("STREAM_CONSUMER_METADATA");
+function StreamConsumer(options) {
+  return (target, propertyKey, descriptor) => {
+    common.SetMetadata(STREAM_CONSUMER_METADATA, {
+      ...options,
+      methodName: propertyKey
+    })(target, propertyKey, descriptor);
+    return descriptor;
+  };
+}
+
+// src/streams/api/discovery/stream-consumer.discovery.ts
+var StreamConsumerDiscovery = class {
+  constructor(discoveryService, consumerService, reflector, moduleRef) {
+    this.discoveryService = discoveryService;
+    this.consumerService = consumerService;
+    this.reflector = reflector;
+    this.moduleRef = moduleRef;
+  }
+  logger = new common.Logger(StreamConsumerDiscovery.name);
+  handles = [];
+  async onModuleInit() {
+    if (!this.discoveryService) {
+      this.logger.warn("DiscoveryService not available. Import DiscoveryModule from @nestjs/core to enable @StreamConsumer decorator.");
+      return;
+    }
+    const providers = this.discoveryService.getProviders();
+    for (const wrapper of providers) {
+      const { instance } = wrapper;
+      if (!instance) {
+        continue;
+      }
+      const prototype = Object.getPrototypeOf(instance);
+      for (const methodName of Object.getOwnPropertyNames(prototype)) {
+        const method = prototype[methodName];
+        if (typeof method !== "function") {
+          continue;
+        }
+        const options = this.reflector.get(STREAM_CONSUMER_METADATA, method);
+        if (options) {
+          await this.registerConsumer(instance, methodName, options);
+        }
+      }
+    }
+  }
+  async registerConsumer(instance, methodName, options) {
+    const method = instance[methodName];
+    if (!method || typeof method !== "function") {
+      throw new Error(`Method ${methodName} is not a function on instance`);
+    }
+    const handler = method.bind(instance);
+    const consumer = options.consumer ?? `${os__namespace.hostname()}-${process.pid}`;
+    await this.consumerService.createGroup(options.stream, options.group);
+    const handle = this.consumerService.consume(options.stream, options.group, consumer, handler, options);
+    this.handles.push(handle);
+  }
+};
+StreamConsumerDiscovery = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Optional()),
+  __decorateParam(1, common.Inject(STREAM_CONSUMER))
+], StreamConsumerDiscovery);
+var DEFAULT_DLQ_FETCH_COUNT = 100;
+exports.DeadLetterService = class DeadLetterService {
+  constructor(driver, config) {
+    this.driver = driver;
+    this.config = config;
+  }
+  async add(stream, originalId, data, error) {
+    if (!this.config.dlq?.enabled) {
+      return "";
+    }
+    const dlqStream = `${stream}${this.config.dlq.streamSuffix ?? ":dlq"}`;
+    const maxLen = this.config.dlq.maxLen ?? 1e4;
+    return await this.driver.xadd(
+      dlqStream,
+      "*",
+      {
+        data: JSON.stringify(data),
+        originalId,
+        originalStream: stream,
+        error: error?.message ?? "Unknown error",
+        failedAt: Date.now().toString()
+      },
+      { maxLen, approximate: true }
+    );
+  }
+  async getMessages(stream, count = DEFAULT_DLQ_FETCH_COUNT) {
+    const dlqSuffix = this.config.dlq?.streamSuffix ?? ":dlq";
+    const dlqStream = `${stream}${dlqSuffix}`;
+    const entries = await this.driver.xrange(dlqStream, "-", "+", { count });
+    return entries.map((entry) => ({
+      id: entry.id,
+      data: JSON.parse(entry.fields.data),
+      originalId: entry.fields.originalId,
+      originalStream: entry.fields.originalStream,
+      error: entry.fields.error,
+      failedAt: new Date(parseInt(entry.fields.failedAt, 10))
+    }));
+  }
+  async requeue(dlqMessageId, stream) {
+    const dlqSuffix = this.config.dlq?.streamSuffix ?? ":dlq";
+    const dlqStream = `${stream}${dlqSuffix}`;
+    const entries = await this.driver.xrange(dlqStream, dlqMessageId, dlqMessageId);
+    if (!entries.length) {
+      throw new Error(`DLQ message ${dlqMessageId} not found`);
+    }
+    const entry = entries[0];
+    const newId = await this.driver.xadd(stream, "*", {
+      data: entry.fields.data,
+      _attempt: "1"
+    });
+    await this.driver.xdel(dlqStream, dlqMessageId);
+    return newId;
+  }
+  async purge(stream) {
+    const dlqSuffix = this.config.dlq?.streamSuffix ?? ":dlq";
+    const dlqStream = `${stream}${dlqSuffix}`;
+    return await this.driver.del(dlqStream);
+  }
+};
+exports.DeadLetterService = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(core.REDIS_DRIVER)),
+  __decorateParam(1, common.Inject(STREAMS_PLUGIN_OPTIONS))
+], exports.DeadLetterService);
+
+// src/streams/domain/entities/stream-message.entity.ts
+var StreamMessage = class {
+  constructor(id, stream, data, attempt, timestamp, ackFn, rejectFn) {
+    this.id = id;
+    this.stream = stream;
+    this.data = data;
+    this.attempt = attempt;
+    this.timestamp = timestamp;
+    this.ackFn = ackFn;
+    this.rejectFn = rejectFn;
+  }
+  async ack() {
+    await this.ackFn();
+  }
+  async reject(error) {
+    await this.rejectFn(error);
+  }
+};
+
+// src/streams/application/services/consumer-instance.ts
+var STOP_POLL_INTERVAL_MS = 100;
+var BACKPRESSURE_WAIT_MS = 10;
+var ERROR_RETRY_DELAY_MS = 1e3;
+var ConsumerInstance = class _ConsumerInstance {
+  constructor(driver, dlqService, config, metrics) {
+    this.driver = driver;
+    this.dlqService = dlqService;
+    this.config = config;
+    this.metrics = metrics;
+  }
+  logger = new common.Logger(_ConsumerInstance.name);
+  running = false;
+  processing = 0;
+  async start() {
+    this.running = true;
+    await this.ensureGroup();
+    void this.poll();
+  }
+  async stop() {
+    this.running = false;
+    while (this.processing > 0) {
+      await new Promise((r) => setTimeout(r, STOP_POLL_INTERVAL_MS));
+    }
+  }
+  async ensureGroup() {
+    try {
+      await this.driver.xgroupCreate(this.config.stream, this.config.group, this.config.startId === ">" ? "$" : "0", true);
+    } catch (error) {
+      if (!error.message.includes("BUSYGROUP")) {
+        throw error;
+      }
+    }
+  }
+  async poll() {
+    while (this.running) {
+      try {
+        while (this.processing >= this.config.concurrency) {
+          await new Promise((r) => setTimeout(r, BACKPRESSURE_WAIT_MS));
+        }
+        const result = await this.driver.xreadgroup(this.config.group, this.config.consumer, [{ key: this.config.stream, id: ">" }], {
+          count: this.config.batchSize,
+          block: this.config.blockTimeout
+        });
+        if (!result?.length) {
+          continue;
+        }
+        for (const streamResult of result) {
+          for (const entry of streamResult.entries) {
+            void this.processMessage(entry.id, entry.fields);
+          }
+        }
+      } catch (error) {
+        this.logger.error("Stream consumer error:", error);
+        await new Promise((r) => setTimeout(r, ERROR_RETRY_DELAY_MS));
+      }
+    }
+  }
+  async processMessage(id, fields) {
+    this.processing++;
+    const startTime = Date.now();
+    const labels = { stream: this.config.stream, group: this.config.group };
+    try {
+      const data = JSON.parse(fields.data);
+      const attempt = parseInt(fields._attempt ?? "1", 10);
+      const timestamp = new Date(parseInt(id.split("-")[0], 10));
+      const message = new StreamMessage(
+        id,
+        this.config.stream,
+        data,
+        attempt,
+        timestamp,
+        () => this.ack(id),
+        (error) => this.handleFailure(id, data, attempt, error)
+      );
+      await this.config.handler(message);
+      await this.ack(id);
+      this.metrics?.incrementCounter("redisx_stream_messages_consumed_total", { ...labels, status: "success" });
+      this.metrics?.observeHistogram("redisx_stream_processing_duration_seconds", (Date.now() - startTime) / 1e3, labels);
+    } catch (error) {
+      const attempt = parseInt(fields._attempt ?? "1", 10);
+      await this.handleFailure(id, JSON.parse(fields.data), attempt, error);
+      this.metrics?.incrementCounter("redisx_stream_messages_consumed_total", { ...labels, status: "error" });
+      this.metrics?.observeHistogram("redisx_stream_processing_duration_seconds", (Date.now() - startTime) / 1e3, labels);
+    } finally {
+      this.processing--;
+    }
+  }
+  async ack(id) {
+    await this.driver.xack(this.config.stream, this.config.group, id);
+  }
+  async handleFailure(id, data, attempt, error) {
+    if (attempt >= this.config.maxRetries) {
+      await this.dlqService.add(this.config.stream, id, data, error);
+      await this.ack(id);
+      this.metrics?.incrementCounter("redisx_stream_messages_consumed_total", {
+        stream: this.config.stream,
+        group: this.config.group,
+        status: "dead_letter"
+      });
+    } else {
+      const delay = Math.min(this.config.retryInitialDelay * Math.pow(this.config.retryMultiplier, attempt - 1), this.config.retryMaxDelay);
+      await new Promise((r) => setTimeout(r, delay));
+      await this.driver.xadd(this.config.stream, "*", {
+        data: JSON.stringify(data),
+        _attempt: String(attempt + 1)
+      });
+      await this.ack(id);
+      this.metrics?.incrementCounter("redisx_stream_messages_consumed_total", {
+        stream: this.config.stream,
+        group: this.config.group,
+        status: "retry"
+      });
+    }
+  }
+};
+
+// src/streams/application/services/stream-consumer.service.ts
+var METRICS_SERVICE = /* @__PURE__ */ Symbol.for("METRICS_SERVICE");
+exports.StreamConsumerService = class StreamConsumerService {
+  constructor(driver, config, dlqService, metrics) {
+    this.driver = driver;
+    this.config = config;
+    this.dlqService = dlqService;
+    this.metrics = metrics;
+  }
+  consumers = /* @__PURE__ */ new Map();
+  async onModuleDestroy() {
+    await Promise.all(Array.from(this.consumers.values()).map((c) => c.stop()));
+  }
+  consume(stream, group, consumer, handler, options = {}) {
+    const id = `${stream}:${group}:${consumer}`;
+    if (this.consumers.has(id)) {
+      throw new Error(`Consumer ${id} already exists`);
+    }
+    const instance = new ConsumerInstance(
+      this.driver,
+      this.dlqService,
+      {
+        stream,
+        group,
+        consumer,
+        handler,
+        batchSize: options.batchSize ?? this.config.consumer?.batchSize ?? 10,
+        blockTimeout: options.blockTimeout ?? this.config.consumer?.blockTimeout ?? 5e3,
+        maxRetries: options.maxRetries ?? this.config.consumer?.maxRetries ?? 3,
+        concurrency: options.concurrency ?? this.config.consumer?.concurrency ?? 1,
+        startId: options.startId ?? ">",
+        retryInitialDelay: this.config.retry?.initialDelay ?? 1e3,
+        retryMaxDelay: this.config.retry?.maxDelay ?? 3e4,
+        retryMultiplier: this.config.retry?.multiplier ?? 2
+      },
+      this.metrics
+    );
+    this.consumers.set(id, instance);
+    void instance.start();
+    return { id, isRunning: true };
+  }
+  async stop(handle) {
+    const instance = this.consumers.get(handle.id);
+    if (instance) {
+      await instance.stop();
+      this.consumers.delete(handle.id);
+    }
+  }
+  async createGroup(stream, group, startId = "0") {
+    try {
+      await this.driver.xgroupCreate(stream, group, startId, true);
+    } catch (error) {
+      if (!error.message.includes("BUSYGROUP")) {
+        throw error;
+      }
+    }
+  }
+  async getPending(stream, group) {
+    const result = await this.driver.xpending(stream, group);
+    return {
+      count: result.count,
+      minId: result.minId ?? "",
+      maxId: result.maxId ?? "",
+      consumers: result.consumers.map((c) => ({
+        name: c.name,
+        pending: c.count
+      }))
+    };
+  }
+  async claimIdle(stream, group, consumer, minIdleTime) {
+    const pending = await this.driver.xpendingRange(stream, group, "-", "+", 100);
+    const idlePending = pending.filter((entry) => entry.idleTime >= minIdleTime);
+    if (idlePending.length === 0) {
+      return [];
+    }
+    const ids = idlePending.map((entry) => entry.id);
+    const claimed = await this.driver.xclaim(stream, group, consumer, minIdleTime, ...ids);
+    const maxRetries = this.config.consumer?.maxRetries ?? 3;
+    return claimed.map((entry) => {
+      const data = JSON.parse(entry.fields.data ?? "{}");
+      const attempt = parseInt(entry.fields._attempt ?? "1", 10);
+      const timestamp = new Date(parseInt(entry.id.split("-")[0], 10));
+      return {
+        id: entry.id,
+        stream,
+        data,
+        attempt,
+        timestamp,
+        ack: () => this.driver.xack(stream, group, entry.id).then(() => {
+        }),
+        reject: async (error) => {
+          if (attempt >= maxRetries) {
+            await this.dlqService.add(stream, entry.id, data, error);
+          } else {
+            await this.driver.xadd(stream, "*", {
+              data: JSON.stringify(data),
+              _attempt: String(attempt + 1)
+            });
+          }
+          await this.driver.xack(stream, group, entry.id);
+        }
+      };
+    });
+  }
+};
+exports.StreamConsumerService = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(core.REDIS_DRIVER)),
+  __decorateParam(1, common.Inject(STREAMS_PLUGIN_OPTIONS)),
+  __decorateParam(2, common.Inject(DEAD_LETTER_SERVICE)),
+  __decorateParam(3, common.Optional()),
+  __decorateParam(3, common.Inject(METRICS_SERVICE))
+], exports.StreamConsumerService);
+var StreamError = class extends core.RedisXError {
+  constructor(message, code, stream, cause) {
+    super(message, code, cause, { stream });
+    this.stream = stream;
+  }
+};
+var StreamPublishError = class extends StreamError {
+  constructor(stream, cause) {
+    super(`Failed to publish to stream "${stream}"`, core.ErrorCode.OP_FAILED, stream, cause);
+  }
+};
+var StreamConsumeError = class extends StreamError {
+  constructor(stream, cause) {
+    super(`Failed to consume from stream "${stream}"`, core.ErrorCode.STREAM_READ_FAILED, stream, cause);
+  }
+};
+var StreamGroupError = class extends StreamError {
+  constructor(stream, group, cause) {
+    super(`Failed to access group "${group}" on stream "${stream}"`, core.ErrorCode.STREAM_CONSUMER_GROUP_ERROR, stream, cause);
+  }
+};
+
+// src/streams/application/services/stream-producer.service.ts
+var METRICS_SERVICE2 = /* @__PURE__ */ Symbol.for("METRICS_SERVICE");
+exports.StreamProducerService = class StreamProducerService {
+  constructor(driver, config, metrics) {
+    this.driver = driver;
+    this.config = config;
+    this.metrics = metrics;
+  }
+  async publish(stream, data, options = {}) {
+    const startTime = Date.now();
+    try {
+      const maxLen = options.maxLen ?? this.config.producer?.maxLen ?? 1e5;
+      const id = options.id ?? "*";
+      const result = await this.driver.xadd(stream, id, { data: JSON.stringify(data) }, { maxLen, approximate: true });
+      this.metrics?.incrementCounter("redisx_stream_messages_published_total", { stream });
+      this.metrics?.observeHistogram("redisx_stream_publish_duration_seconds", (Date.now() - startTime) / 1e3, { stream });
+      return result;
+    } catch (error) {
+      this.metrics?.incrementCounter("redisx_stream_publish_errors_total", { stream });
+      throw new StreamPublishError(stream, error);
+    }
+  }
+  async publishBatch(stream, messages, options = {}) {
+    const startTime = Date.now();
+    try {
+      const maxLen = options.maxLen ?? this.config.producer?.maxLen ?? 1e5;
+      const results = [];
+      for (const data of messages) {
+        const id = await this.driver.xadd(stream, "*", { data: JSON.stringify(data) }, { maxLen, approximate: true });
+        results.push(id);
+      }
+      this.metrics?.incrementCounter("redisx_stream_messages_published_total", { stream }, messages.length);
+      this.metrics?.observeHistogram("redisx_stream_publish_duration_seconds", (Date.now() - startTime) / 1e3, { stream });
+      return results;
+    } catch (error) {
+      this.metrics?.incrementCounter("redisx_stream_publish_errors_total", { stream });
+      throw new StreamPublishError(stream, error);
+    }
+  }
+  async getStreamInfo(stream) {
+    try {
+      const info = await this.driver.xinfo(stream);
+      return {
+        length: info.length,
+        firstEntry: info.firstEntry ? {
+          id: info.firstEntry.id,
+          timestamp: new Date(parseInt(info.firstEntry.id.split("-")[0] ?? "0", 10))
+        } : void 0,
+        lastEntry: info.lastEntry ? {
+          id: info.lastEntry.id,
+          timestamp: new Date(parseInt(info.lastEntry.id.split("-")[0] ?? "0", 10))
+        } : void 0,
+        groups: info.groups
+      };
+    } catch {
+      return {
+        length: 0,
+        groups: 0
+      };
+    }
+  }
+  async trim(stream, maxLen) {
+    return await this.driver.xtrim(stream, maxLen, true);
+  }
+};
+exports.StreamProducerService = __decorateClass([
+  common.Injectable(),
+  __decorateParam(0, common.Inject(core.REDIS_DRIVER)),
+  __decorateParam(1, common.Inject(STREAMS_PLUGIN_OPTIONS)),
+  __decorateParam(2, common.Optional()),
+  __decorateParam(2, common.Inject(METRICS_SERVICE2))
+], exports.StreamProducerService);
+
+// src/streams.plugin.ts
+var DEFAULT_STREAMS_CONFIG = {
+  keyPrefix: "stream:",
+  consumer: {
+    batchSize: 10,
+    blockTimeout: 5e3,
+    concurrency: 1,
+    maxRetries: 3,
+    claimIdleTimeout: 3e4
+  },
+  producer: {
+    maxLen: 1e5,
+    autoCreate: true
+  },
+  dlq: {
+    enabled: true,
+    streamSuffix: ":dlq",
+    maxLen: 1e4
+  },
+  retry: {
+    maxRetries: 3,
+    initialDelay: 1e3,
+    maxDelay: 3e4,
+    multiplier: 2
+  },
+  trim: {
+    enabled: true,
+    maxLen: 1e5,
+    strategy: "MAXLEN",
+    approximate: true
+  }
+};
+var StreamsPlugin = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  name = "streams";
+  version = "0.1.0";
+  description = "Redis Streams support with consumer groups and DLQ";
+  getProviders() {
+    const config = {
+      keyPrefix: this.options.keyPrefix ?? DEFAULT_STREAMS_CONFIG.keyPrefix,
+      consumer: {
+        ...DEFAULT_STREAMS_CONFIG.consumer,
+        ...this.options.consumer
+      },
+      producer: {
+        ...DEFAULT_STREAMS_CONFIG.producer,
+        ...this.options.producer
+      },
+      dlq: {
+        ...DEFAULT_STREAMS_CONFIG.dlq,
+        ...this.options.dlq
+      },
+      retry: {
+        ...DEFAULT_STREAMS_CONFIG.retry,
+        ...this.options.retry
+      },
+      trim: {
+        ...DEFAULT_STREAMS_CONFIG.trim,
+        ...this.options.trim
+      }
+    };
+    return [{ provide: STREAMS_PLUGIN_OPTIONS, useValue: config }, { provide: DEAD_LETTER_SERVICE, useClass: exports.DeadLetterService }, { provide: STREAM_PRODUCER, useClass: exports.StreamProducerService }, { provide: STREAM_CONSUMER, useClass: exports.StreamConsumerService }, StreamConsumerDiscovery];
+  }
+  getExports() {
+    return [STREAM_PRODUCER, STREAM_CONSUMER, DEAD_LETTER_SERVICE];
+  }
+};
+
+exports.DEAD_LETTER_SERVICE = DEAD_LETTER_SERVICE;
+exports.STREAMS_PLUGIN_OPTIONS = STREAMS_PLUGIN_OPTIONS;
+exports.STREAM_CONSUMER = STREAM_CONSUMER;
+exports.STREAM_CONSUMER_METADATA = STREAM_CONSUMER_METADATA;
+exports.STREAM_PRODUCER = STREAM_PRODUCER;
+exports.StreamConsumeError = StreamConsumeError;
+exports.StreamConsumer = StreamConsumer;
+exports.StreamError = StreamError;
+exports.StreamGroupError = StreamGroupError;
+exports.StreamMessage = StreamMessage;
+exports.StreamPublishError = StreamPublishError;
+exports.StreamsPlugin = StreamsPlugin;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map