@quanticjs/core 1.1.1 → 2.0.0

package/dist/cqrs/behaviors/PerformanceBehavior.js

@@ -1,56 +0,0 @@
-"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.PerformanceBehavior = void 0;
-const common_1 = require("@nestjs/common");
-const MetricsService_1 = require("../../metrics/MetricsService");
-const SLOW_THRESHOLD_MS = 500;
-/**
- * PerformanceBehavior logs a warning when a handler exceeds 500ms
- * and records handler duration in Prometheus histogram.
- */
-let PerformanceBehavior = class PerformanceBehavior {
-    metrics;
-    logger = new common_1.Logger('PerformanceBehavior');
-    constructor(metrics) {
-        this.metrics = metrics;
-    }
-    async execute(command, next) {
-        const handlerName = command.constructor.name;
-        const startTime = Date.now();
-        const result = await next();
-        const durationMs = Date.now() - startTime;
-        const durationSec = durationMs / 1000;
-        const resultLabel = result.isSuccess ? 'success' : 'failure';
-        // Record metrics
-        this.metrics?.handlerDuration
-            .labels(handlerName, resultLabel)
-            .observe(durationSec);
-        // Warn on slow handlers
-        if (durationMs > SLOW_THRESHOLD_MS) {
-            this.logger.warn({
-                msg: `Slow handler detected: ${handlerName} took ${durationMs}ms`,
-                handler: handlerName,
-                durationMs,
-            });
-        }
-        return result;
-    }
-};
-exports.PerformanceBehavior = PerformanceBehavior;
-exports.PerformanceBehavior = PerformanceBehavior = __decorate([
-    (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Optional)()),
-    __metadata("design:paramtypes", [MetricsService_1.MetricsService])
-], PerformanceBehavior);

package/dist/cqrs/behaviors/WorkflowBehavior.d.ts

@@ -1,8 +0,0 @@
-import { WorkflowEngine } from '../interfaces/WorkflowEngine';
-import { Result } from '../../result/Result';
-export declare class WorkflowBehavior {
-    private readonly engine?;
-    private readonly logger;
-    constructor(engine?: WorkflowEngine | undefined);
-    execute<T>(command: object, next: () => Promise<Result<T>>): Promise<Result<T>>;
-}

package/dist/cqrs/behaviors/WorkflowBehavior.js

@@ -1,61 +0,0 @@
-"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 WorkflowBehavior_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowBehavior = void 0;
-const common_1 = require("@nestjs/common");
-const Workflow_decorator_1 = require("../decorators/Workflow.decorator");
-const WorkflowEngine_1 = require("../interfaces/WorkflowEngine");
-const Result_1 = require("../../result/Result");
-let WorkflowBehavior = WorkflowBehavior_1 = class WorkflowBehavior {
-    engine;
-    logger = new common_1.Logger(WorkflowBehavior_1.name);
-    constructor(engine) {
-        this.engine = engine;
-    }
-    async execute(command, next) {
-        const metadata = (0, Workflow_decorator_1.getWorkflowMetadata)(command.constructor);
-        if (!metadata) {
-            return next();
-        }
-        if (!this.engine) {
-            this.logger.debug('No WorkflowEngine provided, skipping workflow behavior');
-            return next();
-        }
-        try {
-            const result = await this.engine.startProcess(metadata.processDefinitionId, command, { commandType: command.constructor.name });
-            return Result_1.Result.success(result);
-        }
-        catch (error) {
-            const fallback = metadata.fallback ?? 'throw';
-            this.logger.warn(`Workflow start failed for "${metadata.processDefinitionId}", applying fallback: ${fallback}`, error.message);
-            switch (fallback) {
-                case 'skip':
-                    return next();
-                case 'queue':
-                    return Result_1.Result.failure(Result_1.ErrorType.InternalError, `Workflow queuing not available without companion package: ${error.message}`);
-                case 'throw':
-                default:
-                    return Result_1.Result.failure(Result_1.ErrorType.InternalError, `Workflow start failed: ${error.message}`);
-            }
-        }
-    }
-};
-exports.WorkflowBehavior = WorkflowBehavior;
-exports.WorkflowBehavior = WorkflowBehavior = WorkflowBehavior_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Optional)()),
-    __param(0, (0, common_1.Inject)(WorkflowEngine_1.WORKFLOW_ENGINE)),
-    __metadata("design:paramtypes", [Object])
-], WorkflowBehavior);

package/dist/events/DomainEvent.d.ts

@@ -1,14 +0,0 @@
-export interface DomainEventPayload {
-    [key: string]: unknown;
-}
-export declare class DomainEvent {
-    readonly eventType: string;
-    readonly aggregateId: string;
-    readonly payload: DomainEventPayload;
-    readonly organizationId?: string | undefined;
-    readonly eventId: string;
-    readonly occurredAt: Date;
-    constructor(eventType: string, aggregateId: string, payload: DomainEventPayload, organizationId?: string | undefined);
-    /** The Redis Stream key this event should be published to */
-    get streamKey(): string;
-}

package/dist/events/DomainEvent.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DomainEvent = void 0;
-const uuid_1 = require("uuid");
-class DomainEvent {
-    eventType;
-    aggregateId;
-    payload;
-    organizationId;
-    eventId;
-    occurredAt;
-    constructor(eventType, aggregateId, payload, organizationId) {
-        this.eventType = eventType;
-        this.aggregateId = aggregateId;
-        this.payload = payload;
-        this.organizationId = organizationId;
-        this.eventId = (0, uuid_1.v4)();
-        this.occurredAt = new Date();
-    }
-    /** The Redis Stream key this event should be published to */
-    get streamKey() {
-        // e.g. 'build.completed' → 'arex:events:builds'
-        const category = this.eventType.split('.')[0];
-        return `arex:events:${category}s`;
-    }
-}
-exports.DomainEvent = DomainEvent;

package/dist/events/OutboxEvent.entity.d.ts

@@ -1,18 +0,0 @@
-export declare enum OutboxEventStatus {
-    Pending = "Pending",
-    Published = "Published",
-    Failed = "Failed"
-}
-export declare class OutboxEvent {
-    id: string;
-    eventType: string;
-    aggregateId: string;
-    streamKey: string;
-    payload: Record<string, unknown>;
-    organizationId: string | null;
-    status: OutboxEventStatus;
-    publishAttempts: number;
-    lastError: string | null;
-    createdAt: Date;
-    publishedAt: Date | null;
-}

package/dist/events/OutboxEvent.entity.js

@@ -1,87 +0,0 @@
-"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);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OutboxEvent = exports.OutboxEventStatus = void 0;
-const typeorm_1 = require("typeorm");
-var OutboxEventStatus;
-(function (OutboxEventStatus) {
-    OutboxEventStatus["Pending"] = "Pending";
-    OutboxEventStatus["Published"] = "Published";
-    OutboxEventStatus["Failed"] = "Failed";
-})(OutboxEventStatus || (exports.OutboxEventStatus = OutboxEventStatus = {}));
-let OutboxEvent = class OutboxEvent {
-    id;
-    eventType;
-    aggregateId;
-    streamKey;
-    payload;
-    organizationId;
-    status;
-    publishAttempts;
-    lastError;
-    createdAt;
-    publishedAt;
-};
-exports.OutboxEvent = OutboxEvent;
-__decorate([
-    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
-    __metadata("design:type", String)
-], OutboxEvent.prototype, "id", void 0);
-__decorate([
-    (0, typeorm_1.Column)({ type: 'varchar' }),
-    __metadata("design:type", String)
-], OutboxEvent.prototype, "eventType", void 0);
-__decorate([
-    (0, typeorm_1.Column)({ type: 'varchar' }),
-    __metadata("design:type", String)
-], OutboxEvent.prototype, "aggregateId", void 0);
-__decorate([
-    (0, typeorm_1.Column)({ type: 'varchar' }),
-    __metadata("design:type", String)
-], OutboxEvent.prototype, "streamKey", void 0);
-__decorate([
-    (0, typeorm_1.Column)({ type: 'jsonb' }),
-    __metadata("design:type", Object)
-], OutboxEvent.prototype, "payload", void 0);
-__decorate([
-    (0, typeorm_1.Column)({ type: 'uuid', nullable: true }),
-    __metadata("design:type", Object)
-], OutboxEvent.prototype, "organizationId", void 0);
-__decorate([
-    (0, typeorm_1.Column)({
-        type: 'enum',
-        enum: OutboxEventStatus,
-        default: OutboxEventStatus.Pending,
-    }),
-    __metadata("design:type", String)
-], OutboxEvent.prototype, "status", void 0);
-__decorate([
-    (0, typeorm_1.Column)({ type: 'int', default: 0 }),
-    __metadata("design:type", Number)
-], OutboxEvent.prototype, "publishAttempts", void 0);
-__decorate([
-    (0, typeorm_1.Column)({ type: 'varchar', nullable: true }),
-    __metadata("design:type", Object)
-], OutboxEvent.prototype, "lastError", void 0);
-__decorate([
-    (0, typeorm_1.CreateDateColumn)({ type: 'timestamptz' }),
-    __metadata("design:type", Date)
-], OutboxEvent.prototype, "createdAt", void 0);
-__decorate([
-    (0, typeorm_1.Column)({ type: 'timestamptz', nullable: true }),
-    __metadata("design:type", Object)
-], OutboxEvent.prototype, "publishedAt", void 0);
-exports.OutboxEvent = OutboxEvent = __decorate([
-    (0, typeorm_1.Entity)('outbox_events'),
-    (0, typeorm_1.Index)('idx_outbox_pending', ['status', 'createdAt'], {
-        where: `"status" = 'Pending'`,
-    })
-], OutboxEvent);

package/dist/events/OutboxPublisherService.d.ts

@@ -1,14 +0,0 @@
-import { OnModuleInit, OnModuleDestroy } from '@nestjs/common';
-import { DataSource } from 'typeorm';
-import { RedisStreamPublisher } from './RedisStreamPublisher';
-export declare class OutboxPublisherService implements OnModuleInit, OnModuleDestroy {
-    private readonly dataSource;
-    private readonly redisPublisher;
-    private readonly logger;
-    private timer;
-    private processing;
-    constructor(dataSource: DataSource, redisPublisher: RedisStreamPublisher);
-    onModuleInit(): void;
-    onModuleDestroy(): void;
-    private pollAndPublish;
-}

package/dist/events/OutboxPublisherService.js

@@ -1,104 +0,0 @@
-"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 OutboxPublisherService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OutboxPublisherService = void 0;
-const common_1 = require("@nestjs/common");
-const typeorm_1 = require("typeorm");
-const OutboxEvent_entity_1 = require("./OutboxEvent.entity");
-const RedisStreamPublisher_1 = require("./RedisStreamPublisher");
-const POLL_INTERVAL_MS = 100;
-const BATCH_SIZE = 50;
-const MAX_PUBLISH_ATTEMPTS = 5;
-const DLQ_STREAM = 'arex:events:dlq';
-let OutboxPublisherService = OutboxPublisherService_1 = class OutboxPublisherService {
-    dataSource;
-    redisPublisher;
-    logger = new common_1.Logger(OutboxPublisherService_1.name);
-    timer = null;
-    processing = false;
-    constructor(dataSource, redisPublisher) {
-        this.dataSource = dataSource;
-        this.redisPublisher = redisPublisher;
-    }
-    onModuleInit() {
-        this.timer = setInterval(() => this.pollAndPublish(), POLL_INTERVAL_MS);
-        this.logger.log(`Outbox publisher started (${POLL_INTERVAL_MS}ms poll interval)`);
-    }
-    onModuleDestroy() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-        this.logger.log('Outbox publisher stopped');
-    }
-    async pollAndPublish() {
-        if (this.processing)
-            return;
-        this.processing = true;
-        try {
-            const repo = this.dataSource.getRepository(OutboxEvent_entity_1.OutboxEvent);
-            const events = await repo.find({
-                where: { status: OutboxEvent_entity_1.OutboxEventStatus.Pending },
-                order: { createdAt: 'ASC' },
-                take: BATCH_SIZE,
-            });
-            for (const event of events) {
-                try {
-                    await this.redisPublisher.publishToStream(event.streamKey, {
-                        eventId: event.id,
-                        eventType: event.eventType,
-                        aggregateId: event.aggregateId,
-                        organizationId: event.organizationId || '',
-                        payload: JSON.stringify(event.payload),
-                        occurredAt: event.createdAt.toISOString(),
-                    });
-                    event.status = OutboxEvent_entity_1.OutboxEventStatus.Published;
-                    event.publishedAt = new Date();
-                    await repo.save(event);
-                }
-                catch (error) {
-                    event.publishAttempts += 1;
-                    event.lastError = error.message;
-                    if (event.publishAttempts >= MAX_PUBLISH_ATTEMPTS) {
-                        event.status = OutboxEvent_entity_1.OutboxEventStatus.Failed;
-                        this.logger.error(`Event ${event.id} exceeded max attempts, routing to DLQ`);
-                        try {
-                            await this.redisPublisher.publishToStream(DLQ_STREAM, {
-                                eventId: event.id,
-                                eventType: event.eventType,
-                                aggregateId: event.aggregateId,
-                                error: event.lastError || 'unknown',
-                                payload: JSON.stringify(event.payload),
-                            });
-                        }
-                        catch {
-                            this.logger.error(`Failed to route event ${event.id} to DLQ`);
-                        }
-                    }
-                    await repo.save(event);
-                }
-            }
-        }
-        catch (error) {
-            this.logger.error('Outbox poll cycle failed', error.stack);
-        }
-        finally {
-            this.processing = false;
-        }
-    }
-};
-exports.OutboxPublisherService = OutboxPublisherService;
-exports.OutboxPublisherService = OutboxPublisherService = OutboxPublisherService_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [typeorm_1.DataSource,
-        RedisStreamPublisher_1.RedisStreamPublisher])
-], OutboxPublisherService);

package/dist/events/RedisStreamConsumer.d.ts

@@ -1,43 +0,0 @@
-import { Logger, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
-import type { Redis } from 'ioredis';
-/**
- * Abstract base class for Redis Stream consumer groups.
- *
- * Subclasses declare `streamKey`, `consumerGroup`, `consumerName`
- * and implement `handleMessage(fields)`.
- *
- * Lifecycle:
- *  - OnModuleInit: creates consumer group (idempotent), starts read loop
- *  - OnModuleDestroy: stops the read loop gracefully, disconnects dedicated client
- *
- * Connection strategy:
- *  - Shared REDIS_CLIENT: used for non-blocking ops (XGROUP CREATE, XACK)
- *  - Dedicated cloned connection: used ONLY for blocking XREADGROUP BLOCK calls
- *  - This prevents blocking consumers from starving non-blocking callers
- *    (cache, distributed locks, publishers) that share the main REDIS_CLIENT.
- *
- * Features:
- *  - Auto-creates consumer group via XGROUP CREATE ... MKSTREAM
- *  - Recovers pending (unacked) messages on startup before reading new ones
- *  - XREADGROUP BLOCK for efficient new-message polling (on dedicated connection)
- *  - XACK after successful processing (on shared connection)
- *  - Graceful shutdown (finishes in-flight message, disconnects dedicated client)
- */
-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;
-    /** Override to filter by eventType. Return true to process. Default: all messages. */
-    protected shouldHandle(_fields: Record<string, string>): boolean;
-    abstract handleMessage(fields: Record<string, string>): Promise<void>;
-    private running;
-    /** Dedicated connection for blocking XREADGROUP — cloned from shared client on init */
-    private blockingClient?;
-    constructor(redis?: Redis | undefined);
-    onModuleInit(): Promise<void>;
-    onModuleDestroy(): Promise<void>;
-    private consumeLoop;
-    private readMessages;
-}

package/dist/events/RedisStreamConsumer.js

@@ -1,158 +0,0 @@
-"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 constants_1 = require("../cqrs/constants");
-/**
- * Abstract base class for Redis Stream consumer groups.
- *
- * Subclasses declare `streamKey`, `consumerGroup`, `consumerName`
- * and implement `handleMessage(fields)`.
- *
- * Lifecycle:
- *  - OnModuleInit: creates consumer group (idempotent), starts read loop
- *  - OnModuleDestroy: stops the read loop gracefully, disconnects dedicated client
- *
- * Connection strategy:
- *  - Shared REDIS_CLIENT: used for non-blocking ops (XGROUP CREATE, XACK)
- *  - Dedicated cloned connection: used ONLY for blocking XREADGROUP BLOCK calls
- *  - This prevents blocking consumers from starving non-blocking callers
- *    (cache, distributed locks, publishers) that share the main REDIS_CLIENT.
- *
- * Features:
- *  - Auto-creates consumer group via XGROUP CREATE ... MKSTREAM
- *  - Recovers pending (unacked) messages on startup before reading new ones
- *  - XREADGROUP BLOCK for efficient new-message polling (on dedicated connection)
- *  - XACK after successful processing (on shared connection)
- *  - Graceful shutdown (finishes in-flight message, disconnects dedicated client)
- */
-let RedisStreamConsumer = class RedisStreamConsumer {
-    redis;
-    logger = new common_1.Logger(this.constructor.name);
-    /** Override to filter by eventType. Return true to process. Default: all messages. */
-    shouldHandle(_fields) {
-        return true;
-    }
-    running = false;
-    /** Dedicated connection for blocking XREADGROUP — cloned from shared client on init */
-    blockingClient;
-    constructor(redis) {
-        this.redis = redis;
-    }
-    async onModuleInit() {
-        if (!this.redis) {
-            this.logger.warn('Redis client not available — consumer disabled');
-            return;
-        }
-        // Clone a dedicated connection for blocking reads.
-        // This prevents XREADGROUP BLOCK from starving cache/lock/publish ops on the shared client.
-        this.blockingClient = this.redis.duplicate();
-        this.blockingClient.on('error', (err) => this.logger.error(`Blocking client error on ${this.streamKey}: ${err.message}`));
-        // Create consumer group (idempotent) — uses shared client (non-blocking)
-        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;
-            }
-            // Group already exists — fine
-        }
-        this.running = true;
-        // Process pending messages first, then new ones
-        // Run in background so NestJS startup isn't blocked
-        void this.consumeLoop();
-    }
-    async onModuleDestroy() {
-        this.running = false;
-        // Disconnect the dedicated blocking client
-        if (this.blockingClient) {
-            this.blockingClient.disconnect();
-            this.blockingClient = undefined;
-        }
-    }
-    async consumeLoop() {
-        // Phase 1: recover pending (unacked) messages
-        await this.readMessages('0');
-        // Phase 2: read new messages
-        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);
-            // Use dedicated blocking client for XREADGROUP — never the shared REDIS_CLIENT
-            const results = await this.blockingClient.xreadgroup(...args);
-            if (!results || results.length === 0) {
-                if (id === '0')
-                    return; // No pending — switch to new messages
-                return;
-            }
-            const [, entries] = results[0];
-            if (entries.length === 0 && id === '0') {
-                return; // All pending recovered
-            }
-            for (const [messageId, fieldArray] of entries) {
-                // Parse flat field array into Record
-                const fields = {};
-                for (let i = 0; i < fieldArray.length; i += 2) {
-                    fields[fieldArray[i]] = fieldArray[i + 1];
-                }
-                if (!this.shouldHandle(fields)) {
-                    // Ack and skip — uses shared client (non-blocking)
-                    await this.redis.xack(this.streamKey, this.consumerGroup, messageId);
-                    continue;
-                }
-                try {
-                    await this.handleMessage(fields);
-                    // XACK on shared client — non-blocking
-                    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);
-                    // Don't ack — message stays pending for retry on next startup
-                }
-            }
-        }
-        catch (err) {
-            if (!this.running)
-                return; // Shutdown in progress
-            this.logger.error(`Consumer read error on ${this.streamKey}: ${err.message}`, err.stack);
-            // Back off before retrying
-            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)(constants_1.REDIS_CLIENT)),
-    __metadata("design:paramtypes", [Function])
-], RedisStreamConsumer);

package/dist/events/RedisStreamPublisher.d.ts

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

package/dist/events/RedisStreamPublisher.js

@@ -1,60 +0,0 @@
-"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 constants_1 = require("../cqrs/constants");
-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;
-        }
-        await this.publishToStream(event.streamKey, {
-            eventId: event.eventId,
-            eventType: event.eventType,
-            aggregateId: event.aggregateId,
-            organizationId: event.organizationId || '',
-            payload: JSON.stringify(event.payload),
-            occurredAt: event.occurredAt.toISOString(),
-        });
-    }
-    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;
-        }
-    }
-};
-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)(constants_1.REDIS_CLIENT)),
-    __metadata("design:paramtypes", [Function])
-], RedisStreamPublisher);