@quanticjs/events 2.0.0

package/dist/DomainEvent.d.ts

@@ -0,0 +1,13 @@
+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);
+    get streamKey(): string;
+}

package/dist/DomainEvent.js

@@ -0,0 +1,25 @@
+"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();
+    }
+    get streamKey() {
+        const category = this.eventType.split('.')[0];
+        return `arex:events:${category}s`;
+    }
+}
+exports.DomainEvent = DomainEvent;

package/dist/OutboxEvent.entity.d.ts

@@ -0,0 +1,18 @@
+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/OutboxEvent.entity.js

@@ -0,0 +1,87 @@
+"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/OutboxPublisherService.d.ts

@@ -0,0 +1,14 @@
+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/OutboxPublisherService.js

@@ -0,0 +1,104 @@
+"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/QuanticEventsModule.d.ts

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

package/dist/QuanticEventsModule.js

@@ -0,0 +1,33 @@
+"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 QuanticEventsModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuanticEventsModule = void 0;
+const common_1 = require("@nestjs/common");
+const RedisStreamPublisher_1 = require("./RedisStreamPublisher");
+const OutboxPublisherService_1 = require("./OutboxPublisherService");
+let QuanticEventsModule = QuanticEventsModule_1 = class QuanticEventsModule {
+    static forRoot() {
+        return {
+            module: QuanticEventsModule_1,
+            providers: [
+                RedisStreamPublisher_1.RedisStreamPublisher,
+                OutboxPublisherService_1.OutboxPublisherService,
+            ],
+            exports: [
+                RedisStreamPublisher_1.RedisStreamPublisher,
+                OutboxPublisherService_1.OutboxPublisherService,
+            ],
+        };
+    }
+};
+exports.QuanticEventsModule = QuanticEventsModule;
+exports.QuanticEventsModule = QuanticEventsModule = QuanticEventsModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], QuanticEventsModule);

package/dist/RedisStreamConsumer.d.ts

@@ -0,0 +1,18 @@
+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 running;
+    private blockingClient?;
+    constructor(redis?: Redis | undefined);
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    private consumeLoop;
+    private readMessages;
+}

package/dist/RedisStreamConsumer.js

@@ -0,0 +1,118 @@
+"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;
+    }
+    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 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 this.handleMessage(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,9 @@
+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/RedisStreamPublisher.js

@@ -0,0 +1,60 @@
+"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;
+        }
+        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)(core_1.REDIS_CLIENT)),
+    __metadata("design:paramtypes", [Function])
+], RedisStreamPublisher);

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { DomainEvent } from './DomainEvent';
+export type { DomainEventPayload } from './DomainEvent';
+export { OutboxEvent, OutboxEventStatus } from './OutboxEvent.entity';
+export { RedisStreamPublisher } from './RedisStreamPublisher';
+export { RedisStreamConsumer } from './RedisStreamConsumer';
+export { OutboxPublisherService } from './OutboxPublisherService';
+export { QuanticEventsModule } from './QuanticEventsModule';

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuanticEventsModule = exports.OutboxPublisherService = exports.RedisStreamConsumer = exports.RedisStreamPublisher = exports.OutboxEventStatus = exports.OutboxEvent = exports.DomainEvent = void 0;
+var DomainEvent_1 = require("./DomainEvent");
+Object.defineProperty(exports, "DomainEvent", { enumerable: true, get: function () { return DomainEvent_1.DomainEvent; } });
+var OutboxEvent_entity_1 = require("./OutboxEvent.entity");
+Object.defineProperty(exports, "OutboxEvent", { enumerable: true, get: function () { return OutboxEvent_entity_1.OutboxEvent; } });
+Object.defineProperty(exports, "OutboxEventStatus", { enumerable: true, get: function () { return OutboxEvent_entity_1.OutboxEventStatus; } });
+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 OutboxPublisherService_1 = require("./OutboxPublisherService");
+Object.defineProperty(exports, "OutboxPublisherService", { enumerable: true, get: function () { return OutboxPublisherService_1.OutboxPublisherService; } });
+var QuanticEventsModule_1 = require("./QuanticEventsModule");
+Object.defineProperty(exports, "QuanticEventsModule", { enumerable: true, get: function () { return QuanticEventsModule_1.QuanticEventsModule; } });

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@quanticjs/events",
+  "version": "2.0.0",
+  "description": "Domain events for quanticjs — outbox pattern, Redis Streams pub/sub",
+  "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": "^2.0.0",
+    "uuid": "^11.1.0"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "ioredis": "^5.0.0",
+    "typeorm": "^0.3.20"
+  }
+}