@quanticjs/events-redis 6.0.0

package/dist/QuanticEventsRedisModule.d.ts

@@ -0,0 +1,4 @@
+import { DynamicModule } from '@nestjs/common';
+export declare class QuanticEventsRedisModule {
+    static forRoot(): DynamicModule;
+}

package/dist/QuanticEventsRedisModule.js

@@ -0,0 +1,37 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var QuanticEventsRedisModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuanticEventsRedisModule = void 0;
+const common_1 = require("@nestjs/common");
+const events_core_1 = require("@quanticjs/events-core");
+const RedisStreamPublisher_1 = require("./RedisStreamPublisher");
+let QuanticEventsRedisModule = QuanticEventsRedisModule_1 = class QuanticEventsRedisModule {
+    static forRoot() {
+        return {
+            module: QuanticEventsRedisModule_1,
+            imports: [events_core_1.QuanticEventsCoreModule.forRoot()],
+            providers: [
+                RedisStreamPublisher_1.RedisStreamPublisher,
+                {
+                    provide: events_core_1.EVENT_PUBLISHER,
+                    useExisting: RedisStreamPublisher_1.RedisStreamPublisher,
+                },
+            ],
+            exports: [
+                RedisStreamPublisher_1.RedisStreamPublisher,
+                events_core_1.EVENT_PUBLISHER,
+            ],
+        };
+    }
+};
+exports.QuanticEventsRedisModule = QuanticEventsRedisModule;
+exports.QuanticEventsRedisModule = QuanticEventsRedisModule = QuanticEventsRedisModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], QuanticEventsRedisModule);

package/dist/RedisStreamConsumer.d.ts

@@ -0,0 +1,20 @@
+import { Logger, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import type { Redis } from 'ioredis';
+export declare abstract class RedisStreamConsumer implements OnModuleInit, OnModuleDestroy {
+    protected readonly redis?: Redis | undefined;
+    protected readonly logger: Logger;
+    abstract readonly streamKey: string;
+    abstract readonly consumerGroup: string;
+    abstract readonly consumerName: string;
+    protected shouldHandle(_fields: Record<string, string>): boolean;
+    abstract handleMessage(fields: Record<string, string>): Promise<void>;
+    private readonly tracer;
+    private running;
+    private blockingClient?;
+    constructor(redis?: Redis | undefined);
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    private processWithSpan;
+    private consumeLoop;
+    private readMessages;
+}

package/dist/RedisStreamConsumer.js

@@ -0,0 +1,144 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStreamConsumer = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@quanticjs/core");
+let RedisStreamConsumer = class RedisStreamConsumer {
+    redis;
+    logger = new common_1.Logger(this.constructor.name);
+    shouldHandle(_fields) {
+        return true;
+    }
+    tracer = (0, core_1.getTracer)('@quanticjs/events');
+    running = false;
+    blockingClient;
+    constructor(redis) {
+        this.redis = redis;
+    }
+    async onModuleInit() {
+        if (!this.redis) {
+            this.logger.warn('Redis client not available — consumer disabled');
+            return;
+        }
+        this.blockingClient = this.redis.duplicate();
+        this.blockingClient.on('error', (err) => this.logger.error(`Blocking client error on ${this.streamKey}: ${err.message}`));
+        try {
+            await this.redis.xgroup('CREATE', this.streamKey, this.consumerGroup, '0', 'MKSTREAM');
+            this.logger.log(`Created consumer group "${this.consumerGroup}" on "${this.streamKey}"`);
+        }
+        catch (err) {
+            if (!err.message?.includes('BUSYGROUP')) {
+                throw err;
+            }
+        }
+        this.running = true;
+        void this.consumeLoop();
+    }
+    async onModuleDestroy() {
+        this.running = false;
+        if (this.blockingClient) {
+            this.blockingClient.disconnect();
+            this.blockingClient = undefined;
+        }
+    }
+    async processWithSpan(messageId, fields) {
+        if (!this.tracer) {
+            return this.handleMessage(fields);
+        }
+        const spanName = `${this.streamKey} process`;
+        return this.tracer.startActiveSpan(spanName, async (span) => {
+            span.setAttribute('messaging.system', 'redis_stream');
+            span.setAttribute('messaging.destination', this.streamKey);
+            span.setAttribute('messaging.message_id', messageId);
+            if (fields.eventType)
+                span.setAttribute('messaging.event_type', fields.eventType);
+            try {
+                await this.handleMessage(fields);
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                span.setStatus({ code: core_1.SPAN_STATUS_ERROR, message: err.message });
+                span.recordException(err);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    async consumeLoop() {
+        await this.readMessages('0');
+        while (this.running) {
+            await this.readMessages('>');
+        }
+    }
+    async readMessages(id) {
+        if (!this.redis || !this.blockingClient || !this.running)
+            return;
+        try {
+            const blockMs = id === '>' ? 5000 : undefined;
+            const args = [
+                'GROUP',
+                this.consumerGroup,
+                this.consumerName,
+                'COUNT',
+                '10',
+            ];
+            if (blockMs !== undefined) {
+                args.push('BLOCK', blockMs);
+            }
+            args.push('STREAMS', this.streamKey, id);
+            const results = await this.blockingClient.xreadgroup(...args);
+            if (!results || results.length === 0) {
+                if (id === '0')
+                    return;
+                return;
+            }
+            const [, entries] = results[0];
+            if (entries.length === 0 && id === '0') {
+                return;
+            }
+            for (const [messageId, fieldArray] of entries) {
+                const fields = {};
+                for (let i = 0; i < fieldArray.length; i += 2) {
+                    fields[fieldArray[i]] = fieldArray[i + 1];
+                }
+                if (!this.shouldHandle(fields)) {
+                    await this.redis.xack(this.streamKey, this.consumerGroup, messageId);
+                    continue;
+                }
+                try {
+                    await (0, core_1.withExtractedContext)(fields, () => this.processWithSpan(messageId, fields));
+                    await this.redis.xack(this.streamKey, this.consumerGroup, messageId);
+                }
+                catch (err) {
+                    this.logger.error(`Failed to process message ${messageId} on ${this.streamKey}: ${err.message}`, err.stack);
+                }
+            }
+        }
+        catch (err) {
+            if (!this.running)
+                return;
+            this.logger.error(`Consumer read error on ${this.streamKey}: ${err.message}`, err.stack);
+            await new Promise((r) => setTimeout(r, 2000));
+        }
+    }
+};
+exports.RedisStreamConsumer = RedisStreamConsumer;
+exports.RedisStreamConsumer = RedisStreamConsumer = __decorate([
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)(core_1.REDIS_CLIENT)),
+    __metadata("design:paramtypes", [Function])
+], RedisStreamConsumer);

package/dist/RedisStreamPublisher.d.ts

@@ -0,0 +1,11 @@
+import { IEventPublisher, DomainEvent } from '@quanticjs/events-core';
+import type { Redis } from 'ioredis';
+export declare class RedisStreamPublisher implements IEventPublisher {
+    private readonly redis?;
+    private readonly logger;
+    constructor(redis?: Redis | undefined);
+    publish(event: DomainEvent): Promise<void>;
+    publishToDestination(destination: string, fields: Record<string, string>): Promise<string | null>;
+    publishToStream(streamKey: string, fields: Record<string, string>): Promise<string | null>;
+    private topicToStreamKey;
+}

package/dist/RedisStreamPublisher.js

@@ -0,0 +1,70 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var RedisStreamPublisher_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStreamPublisher = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@quanticjs/core");
+const MAX_STREAM_LENGTH = 10000;
+let RedisStreamPublisher = RedisStreamPublisher_1 = class RedisStreamPublisher {
+    redis;
+    logger = new common_1.Logger(RedisStreamPublisher_1.name);
+    constructor(redis) {
+        this.redis = redis;
+    }
+    async publish(event) {
+        if (!this.redis) {
+            this.logger.warn('Redis client not available, skipping event publish');
+            return;
+        }
+        const fields = {
+            eventId: event.eventId,
+            eventType: event.eventType,
+            aggregateId: event.aggregateId,
+            organizationId: event.organizationId || '',
+            payload: JSON.stringify(event.payload),
+            occurredAt: event.occurredAt.toISOString(),
+        };
+        (0, core_1.injectTraceContext)(fields);
+        const streamKey = this.topicToStreamKey(event.topic);
+        await this.publishToStream(streamKey, fields);
+    }
+    async publishToDestination(destination, fields) {
+        const streamKey = this.topicToStreamKey(destination);
+        return this.publishToStream(streamKey, fields);
+    }
+    async publishToStream(streamKey, fields) {
+        if (!this.redis)
+            return null;
+        try {
+            const messageId = await this.redis.xadd(streamKey, 'MAXLEN', '~', String(MAX_STREAM_LENGTH), '*', ...Object.entries(fields).flat());
+            this.logger.debug(`Published to ${streamKey}: ${messageId}`);
+            return messageId;
+        }
+        catch (error) {
+            this.logger.error(`Failed to publish to ${streamKey}`, error.stack);
+            throw error;
+        }
+    }
+    topicToStreamKey(topic) {
+        return topic.replace(/\./g, ':');
+    }
+};
+exports.RedisStreamPublisher = RedisStreamPublisher;
+exports.RedisStreamPublisher = RedisStreamPublisher = RedisStreamPublisher_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)(core_1.REDIS_CLIENT)),
+    __metadata("design:paramtypes", [Function])
+], RedisStreamPublisher);

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { RedisStreamPublisher } from './RedisStreamPublisher';
+export { RedisStreamConsumer } from './RedisStreamConsumer';
+export { QuanticEventsRedisModule } from './QuanticEventsRedisModule';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuanticEventsRedisModule = exports.RedisStreamConsumer = exports.RedisStreamPublisher = void 0;
+var RedisStreamPublisher_1 = require("./RedisStreamPublisher");
+Object.defineProperty(exports, "RedisStreamPublisher", { enumerable: true, get: function () { return RedisStreamPublisher_1.RedisStreamPublisher; } });
+var RedisStreamConsumer_1 = require("./RedisStreamConsumer");
+Object.defineProperty(exports, "RedisStreamConsumer", { enumerable: true, get: function () { return RedisStreamConsumer_1.RedisStreamConsumer; } });
+var QuanticEventsRedisModule_1 = require("./QuanticEventsRedisModule");
+Object.defineProperty(exports, "QuanticEventsRedisModule", { enumerable: true, get: function () { return QuanticEventsRedisModule_1.QuanticEventsRedisModule; } });

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@quanticjs/events-redis",
+  "version": "6.0.0",
+  "description": "Redis Streams transport for @quanticjs/events-core — RedisStreamPublisher, RedisStreamConsumer",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "jest --passWithNoTests",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@quanticjs/core": "^6.0.0",
+    "@quanticjs/events-core": "^6.0.0"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "@opentelemetry/api": "^1.9.0",
+    "ioredis": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
+    }
+  }
+}