@lokative/messaging 0.1.1 → 1.1.2

package/README.md

@@ -23,13 +23,30 @@ npm install redis
 
 ---
 
+## Imports
+
+Transports are isolated behind subpath exports so only the dependency you use gets loaded:
+
+```typescript
+// Core (always needed)
+import { MessagingModule, MessagingPublisher, Incoming, Outgoing } from '@lokative/messaging';
+
+// Pick one transport
+import { NatsTransport } from '@lokative/messaging/nats';
+import { KafkaTransport } from '@lokative/messaging/kafka';
+import { RedisTransport } from '@lokative/messaging/redis';
+```
+
+---
+
 ## Quick Start
 
 ### NATS JetStream
 
 ```typescript
 import { Module } from '@nestjs/common';
-import { MessagingModule, NatsTransport } from '@lokative/messaging';
+import { MessagingModule } from '@lokative/messaging';
+import { NatsTransport } from '@lokative/messaging/nats';
 
 @Module({
   imports: [
@@ -54,7 +71,8 @@ export class AppModule {}
 
 ```typescript
 import { Module } from '@nestjs/common';
-import { MessagingModule, KafkaTransport } from '@lokative/messaging';
+import { MessagingModule } from '@lokative/messaging';
+import { KafkaTransport } from '@lokative/messaging/kafka';
 
 @Module({
   imports: [
@@ -77,7 +95,8 @@ export class AppModule {}
 
 ```typescript
 import { Module } from '@nestjs/common';
-import { MessagingModule, RedisTransport } from '@lokative/messaging';
+import { MessagingModule } from '@lokative/messaging';
+import { RedisTransport } from '@lokative/messaging/redis';
 
 @Module({
   imports: [
@@ -309,7 +328,8 @@ interface SubscribeOptions {
 ```typescript
 // app.module.ts
 import { Module } from '@nestjs/common';
-import { MessagingModule, NatsTransport } from '@lokative/messaging';
+import { MessagingModule } from '@lokative/messaging';
+import { NatsTransport } from '@lokative/messaging/nats';
 import { OrderModule } from './order/order.module';
 
 @Module({
@@ -390,7 +410,7 @@ export class OrderHandler {
 To switch this app to Kafka, change only the module registration:
 
 ```typescript
-import { KafkaTransport } from '@lokative/messaging';
+import { KafkaTransport } from '@lokative/messaging/kafka';
 
 MessagingModule.register({
   transport: KafkaTransport,
@@ -405,7 +425,7 @@ MessagingModule.register({
 Or to Redis:
 
 ```typescript
-import { RedisTransport } from '@lokative/messaging';
+import { RedisTransport } from '@lokative/messaging/redis';
 
 MessagingModule.register({
   transport: RedisTransport,
@@ -421,6 +441,8 @@ No changes needed in services or handlers.
 
 ### Exports
 
+From `@lokative/messaging`:
+
 | Export                     | Type        | Description                                    |
 | -------------------------- | ----------- | ---------------------------------------------- |
 | `MessagingModule`          | Module      | NestJS dynamic module                          |
@@ -432,15 +454,30 @@ No changes needed in services or handlers.
 | `Subscription`             | Interface   | Async-iterable subscription                    |
 | `SubscribeOptions`         | Interface   | Options passed to `subscribe()`                |
 | `MESSAGING_TRANSPORT`      | Token       | DI token for the transport provider            |
-| `NatsTransport`            | Injectable  | Built-in NATS JetStream transport              |
-| `NatsTransportOptions`     | Interface   | Options for `NatsTransport`                    |
-| `KafkaTransport`           | Injectable  | Built-in Kafka transport                       |
-| `KafkaTransportOptions`    | Interface   | Options for `KafkaTransport`                   |
-| `RedisTransport`           | Injectable  | Built-in Redis Pub/Sub transport               |
-| `RedisTransportOptions`    | Interface   | Options for `RedisTransport`                   |
 | `Incoming`                 | Decorator   | Subscribe a method to a subject                |
 | `Outgoing`                 | Decorator   | Auto-publish a method's return value           |
 
+From `@lokative/messaging/nats`:
+
+| Export                | Type        | Description                       |
+| --------------------- | ----------- | --------------------------------- |
+| `NatsTransport`       | Injectable  | Built-in NATS JetStream transport |
+| `NatsTransportOptions`| Interface   | Options for `NatsTransport`       |
+
+From `@lokative/messaging/kafka`:
+
+| Export                 | Type        | Description                |
+| ---------------------- | ----------- | -------------------------- |
+| `KafkaTransport`       | Injectable  | Built-in Kafka transport   |
+| `KafkaTransportOptions`| Interface   | Options for `KafkaTransport` |
+
+From `@lokative/messaging/redis`:
+
+| Export                 | Type        | Description                      |
+| ---------------------- | ----------- | -------------------------------- |
+| `RedisTransport`       | Injectable  | Built-in Redis Pub/Sub transport |
+| `RedisTransportOptions`| Interface   | Options for `RedisTransport`     |
+
 ### Injection
 
 ```typescript

package/dist/cjs/index.d.ts

@@ -0,0 +1,6 @@
+export { MessagingConfig } from './messaging.config';
+export { MessagingTransport, MessageEnvelope, Subscription, SubscribeOptions, MESSAGING_TRANSPORT } from './transport.interface';
+export { Incoming, Outgoing } from './messaging.decorator';
+export { MessagingModule } from './messaging.module';
+export { MessagingPublisher } from './messaging.publisher';
+export { MessagingConsumerRegistry } from './messaging.registry';

package/dist/cjs/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagingConsumerRegistry = exports.MessagingPublisher = exports.MessagingModule = exports.Outgoing = exports.Incoming = exports.MESSAGING_TRANSPORT = void 0;
+var transport_interface_1 = require("./transport.interface");
+Object.defineProperty(exports, "MESSAGING_TRANSPORT", { enumerable: true, get: function () { return transport_interface_1.MESSAGING_TRANSPORT; } });
+var messaging_decorator_1 = require("./messaging.decorator");
+Object.defineProperty(exports, "Incoming", { enumerable: true, get: function () { return messaging_decorator_1.Incoming; } });
+Object.defineProperty(exports, "Outgoing", { enumerable: true, get: function () { return messaging_decorator_1.Outgoing; } });
+var messaging_module_1 = require("./messaging.module");
+Object.defineProperty(exports, "MessagingModule", { enumerable: true, get: function () { return messaging_module_1.MessagingModule; } });
+var messaging_publisher_1 = require("./messaging.publisher");
+Object.defineProperty(exports, "MessagingPublisher", { enumerable: true, get: function () { return messaging_publisher_1.MessagingPublisher; } });
+var messaging_registry_1 = require("./messaging.registry");
+Object.defineProperty(exports, "MessagingConsumerRegistry", { enumerable: true, get: function () { return messaging_registry_1.MessagingConsumerRegistry; } });

package/dist/cjs/kafka.d.ts

@@ -0,0 +1 @@
+export { KafkaTransport, KafkaTransportOptions } from './transports/kafka.transport';

package/dist/cjs/kafka.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaTransport = void 0;
+var kafka_transport_1 = require("./transports/kafka.transport");
+Object.defineProperty(exports, "KafkaTransport", { enumerable: true, get: function () { return kafka_transport_1.KafkaTransport; } });

package/dist/cjs/messaging.config.d.ts

@@ -0,0 +1,15 @@
+import type { Type } from '@nestjs/common';
+import type { MessagingTransport } from './transport.interface';
+export interface MessagingConfig {
+    transport: Type<MessagingTransport>;
+    transportOptions?: Record<string, any>;
+    streams?: {
+        name: string;
+        subjects: string[];
+    }[];
+    consumers?: {
+        group?: string;
+        retry?: number;
+        dlq?: boolean;
+    };
+}

package/dist/cjs/messaging.config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/messaging.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare function Incoming(subject: string): MethodDecorator;
+export declare function Outgoing(subject: string): MethodDecorator;

package/dist/cjs/messaging.decorator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Incoming = Incoming;
+exports.Outgoing = Outgoing;
+function Incoming(subject) {
+    return (target, key) => {
+        Reflect.defineMetadata("msg:incoming", { subject }, target[key]);
+    };
+}
+function Outgoing(subject) {
+    return (target, key, descriptor) => {
+        const original = descriptor.value;
+        descriptor.value = async function (...args) {
+            const result = await original.apply(this, args);
+            const publisher = this.publisher;
+            await publisher.publish(subject, result);
+            return result;
+        };
+    };
+}

package/dist/cjs/messaging.module.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModule } from "@nestjs/common";
+import { MessagingConfig } from "./messaging.config";
+export declare class MessagingModule {
+    static register(config: MessagingConfig): DynamicModule;
+}

package/dist/cjs/messaging.module.js

@@ -0,0 +1,34 @@
+"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 MessagingModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagingModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const transport_interface_1 = require("./transport.interface");
+const messaging_publisher_1 = require("./messaging.publisher");
+const messaging_registry_1 = require("./messaging.registry");
+let MessagingModule = MessagingModule_1 = class MessagingModule {
+    static register(config) {
+        return {
+            module: MessagingModule_1,
+            imports: [core_1.DiscoveryModule],
+            providers: [
+                { provide: "MSG_CONFIG", useValue: config },
+                { provide: transport_interface_1.MESSAGING_TRANSPORT, useClass: config.transport },
+                messaging_publisher_1.MessagingPublisher,
+                messaging_registry_1.MessagingConsumerRegistry,
+            ],
+            exports: [messaging_publisher_1.MessagingPublisher],
+        };
+    }
+};
+exports.MessagingModule = MessagingModule;
+exports.MessagingModule = MessagingModule = MessagingModule_1 = __decorate([
+    (0, common_1.Module)({})
+], MessagingModule);

package/dist/cjs/messaging.publisher.d.ts

@@ -0,0 +1,6 @@
+import { MessagingTransport } from "./transport.interface";
+export declare class MessagingPublisher {
+    private transport;
+    constructor(transport: MessagingTransport);
+    publish(subject: string, payload: any): Promise<void>;
+}

package/dist/cjs/messaging.publisher.js

@@ -0,0 +1,32 @@
+"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.MessagingPublisher = void 0;
+const common_1 = require("@nestjs/common");
+const transport_interface_1 = require("./transport.interface");
+let MessagingPublisher = class MessagingPublisher {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async publish(subject, payload) {
+        await this.transport.publish(subject, payload);
+    }
+};
+exports.MessagingPublisher = MessagingPublisher;
+exports.MessagingPublisher = MessagingPublisher = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(transport_interface_1.MESSAGING_TRANSPORT)),
+    __metadata("design:paramtypes", [Object])
+], MessagingPublisher);

package/dist/cjs/messaging.registry.d.ts

@@ -0,0 +1,12 @@
+import { OnModuleInit } from "@nestjs/common";
+import { DiscoveryService } from "@nestjs/core/discovery";
+import { MessagingTransport } from "./transport.interface";
+import type { MessagingConfig } from "./messaging.config";
+export declare class MessagingConsumerRegistry implements OnModuleInit {
+    private transport;
+    private discovery;
+    private config;
+    constructor(transport: MessagingTransport, discovery: DiscoveryService, config: MessagingConfig);
+    onModuleInit(): Promise<void>;
+    private startConsumer;
+}

package/dist/cjs/messaging.registry.js

@@ -0,0 +1,67 @@
+"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.MessagingConsumerRegistry = void 0;
+const common_1 = require("@nestjs/common");
+const discovery_1 = require("@nestjs/core/discovery");
+const transport_interface_1 = require("./transport.interface");
+let MessagingConsumerRegistry = class MessagingConsumerRegistry {
+    transport;
+    discovery;
+    config;
+    constructor(transport, discovery, config) {
+        this.transport = transport;
+        this.discovery = discovery;
+        this.config = config;
+    }
+    async onModuleInit() {
+        await this.transport.connect();
+        const providers = this.discovery.getProviders();
+        for (const provider of providers) {
+            const instance = provider.instance;
+            if (!instance)
+                continue;
+            const proto = Object.getPrototypeOf(instance);
+            for (const key of Object.getOwnPropertyNames(proto)) {
+                const handler = instance[key];
+                if (typeof handler !== 'function')
+                    continue;
+                const meta = Reflect.getMetadata("msg:incoming", handler);
+                if (!meta)
+                    continue;
+                this.startConsumer(instance, handler, meta);
+            }
+        }
+    }
+    async startConsumer(instance, handler, meta) {
+        const group = this.config.consumers?.group;
+        const sub = await this.transport.subscribe(meta.subject, { group });
+        for await (const msg of sub) {
+            try {
+                await handler.call(instance, msg.data);
+                msg.ack();
+            }
+            catch {
+                msg.nak();
+            }
+        }
+    }
+};
+exports.MessagingConsumerRegistry = MessagingConsumerRegistry;
+exports.MessagingConsumerRegistry = MessagingConsumerRegistry = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(transport_interface_1.MESSAGING_TRANSPORT)),
+    __param(2, (0, common_1.Inject)("MSG_CONFIG")),
+    __metadata("design:paramtypes", [Object, discovery_1.DiscoveryService, Object])
+], MessagingConsumerRegistry);

package/dist/cjs/nats.d.ts

@@ -0,0 +1 @@
+export { NatsTransport, NatsTransportOptions } from './transports/nats.transport';

package/dist/cjs/nats.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsTransport = void 0;
+var nats_transport_1 = require("./transports/nats.transport");
+Object.defineProperty(exports, "NatsTransport", { enumerable: true, get: function () { return nats_transport_1.NatsTransport; } });

package/dist/cjs/redis.d.ts

@@ -0,0 +1 @@
+export { RedisTransport, RedisTransportOptions } from './transports/redis.transport';

package/dist/cjs/redis.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisTransport = void 0;
+var redis_transport_1 = require("./transports/redis.transport");
+Object.defineProperty(exports, "RedisTransport", { enumerable: true, get: function () { return redis_transport_1.RedisTransport; } });

package/dist/cjs/transport.interface.d.ts

@@ -0,0 +1,18 @@
+export interface MessageEnvelope {
+    subject: string;
+    data: any;
+    ack(): void;
+    nak(): void;
+}
+export interface Subscription {
+    [Symbol.asyncIterator](): AsyncIterator<MessageEnvelope>;
+}
+export interface MessagingTransport {
+    connect(): Promise<void>;
+    publish(subject: string, payload: any): Promise<void>;
+    subscribe(subject: string, options?: SubscribeOptions): Promise<Subscription>;
+}
+export interface SubscribeOptions {
+    group?: string;
+}
+export declare const MESSAGING_TRANSPORT = "MESSAGING_TRANSPORT";

package/dist/cjs/transport.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MESSAGING_TRANSPORT = void 0;
+exports.MESSAGING_TRANSPORT = 'MESSAGING_TRANSPORT';

package/dist/cjs/transports/kafka.transport.d.ts

@@ -0,0 +1,15 @@
+import type { MessagingTransport, Subscription, SubscribeOptions } from '../transport.interface';
+import type { MessagingConfig } from '../messaging.config';
+export interface KafkaTransportOptions {
+    brokers: string[];
+    clientId?: string;
+}
+export declare class KafkaTransport implements MessagingTransport {
+    private config;
+    private kafka;
+    private producer;
+    constructor(config: MessagingConfig);
+    connect(): Promise<void>;
+    publish(subject: string, payload: any): Promise<void>;
+    subscribe(subject: string, options?: SubscribeOptions): Promise<Subscription>;
+}

package/dist/cjs/transports/kafka.transport.js

@@ -0,0 +1,82 @@
+"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.KafkaTransport = void 0;
+const common_1 = require("@nestjs/common");
+const kafkajs_1 = require("kafkajs");
+let KafkaTransport = class KafkaTransport {
+    config;
+    kafka;
+    producer;
+    constructor(config) {
+        this.config = config;
+    }
+    async connect() {
+        const opts = this.config.transportOptions;
+        this.kafka = new kafkajs_1.Kafka({
+            clientId: opts.clientId ?? 'nestjs-app',
+            brokers: opts.brokers,
+        });
+        this.producer = this.kafka.producer();
+        await this.producer.connect();
+    }
+    async publish(subject, payload) {
+        await this.producer.send({
+            topic: subject,
+            messages: [{ value: JSON.stringify(payload) }],
+        });
+    }
+    async subscribe(subject, options) {
+        const consumer = this.kafka.consumer({
+            groupId: options?.group ?? 'nest-consumer',
+        });
+        await consumer.connect();
+        await consumer.subscribe({ topic: subject, fromBeginning: false });
+        const buffer = [];
+        let waiting = null;
+        await consumer.run({
+            eachMessage: async ({ topic, message }) => {
+                const envelope = {
+                    subject: topic,
+                    data: JSON.parse(message.value?.toString() ?? '{}'),
+                    ack: () => { }, // kafkajs auto-commits offsets
+                    nak: () => { },
+                };
+                if (waiting) {
+                    const resolve = waiting;
+                    waiting = null;
+                    resolve({ done: false, value: envelope });
+                }
+                else {
+                    buffer.push(envelope);
+                }
+            },
+        });
+        const iterator = {
+            next() {
+                if (buffer.length > 0) {
+                    return Promise.resolve({ done: false, value: buffer.shift() });
+                }
+                return new Promise(r => { waiting = r; });
+            },
+        };
+        return { [Symbol.asyncIterator]: () => iterator };
+    }
+};
+exports.KafkaTransport = KafkaTransport;
+exports.KafkaTransport = KafkaTransport = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)('MSG_CONFIG')),
+    __metadata("design:paramtypes", [Object])
+], KafkaTransport);

package/dist/cjs/transports/nats.transport.d.ts

@@ -0,0 +1,20 @@
+import type { MessagingTransport, Subscription, SubscribeOptions } from '../transport.interface';
+import type { MessagingConfig } from '../messaging.config';
+export interface NatsTransportOptions {
+    servers: string[];
+    streams?: {
+        name: string;
+        subjects: string[];
+    }[];
+}
+export declare class NatsTransport implements MessagingTransport {
+    private config;
+    private nc;
+    private js;
+    private jsm;
+    constructor(config: MessagingConfig);
+    connect(): Promise<void>;
+    publish(subject: string, payload: any): Promise<void>;
+    subscribe(subject: string, options?: SubscribeOptions): Promise<Subscription>;
+    private ensureStreams;
+}

package/dist/cjs/transports/nats.transport.js

@@ -0,0 +1,90 @@
+"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.NatsTransport = void 0;
+const common_1 = require("@nestjs/common");
+const nats_1 = require("nats");
+let NatsTransport = class NatsTransport {
+    config;
+    nc;
+    js;
+    jsm;
+    constructor(config) {
+        this.config = config;
+    }
+    async connect() {
+        const opts = this.config.transportOptions;
+        this.nc = await (0, nats_1.connect)({ servers: opts.servers });
+        this.js = this.nc.jetstream();
+        this.jsm = await this.nc.jetstreamManager();
+        await this.ensureStreams(opts.streams ?? this.config.streams ?? []);
+    }
+    async publish(subject, payload) {
+        await this.js.publish(subject, Buffer.from(JSON.stringify(payload)));
+    }
+    async subscribe(subject, options) {
+        const durable = options?.group ?? 'nest-consumer';
+        const opts = (0, nats_1.consumerOpts)();
+        opts.durable(durable);
+        opts.ackExplicit();
+        opts.deliverTo(durable);
+        const sub = await this.js.subscribe(subject, opts);
+        const iterator = {
+            async next() {
+                const result = await sub[Symbol.asyncIterator]().next();
+                if (result.done)
+                    return { done: true, value: undefined };
+                const msg = result.value;
+                return {
+                    done: false,
+                    value: {
+                        subject: msg.subject,
+                        data: JSON.parse(msg.data.toString()),
+                        ack: () => msg.ack(),
+                        nak: () => msg.nak(),
+                    },
+                };
+            },
+        };
+        return { [Symbol.asyncIterator]: () => iterator };
+    }
+    async ensureStreams(streams) {
+        for (const stream of streams) {
+            try {
+                const info = await this.jsm.streams.info(stream.name);
+                const existing = info.config.subjects ?? [];
+                const missing = stream.subjects.filter(s => !existing.includes(s));
+                if (missing.length > 0) {
+                    info.config.subjects = [...existing, ...missing];
+                    await this.jsm.streams.update(stream.name, info.config);
+                }
+            }
+            catch {
+                try {
+                    await this.jsm.streams.add({ name: stream.name, subjects: stream.subjects });
+                }
+                catch (addErr) {
+                    if (addErr?.api_error?.err_code !== 10065)
+                        throw addErr;
+                }
+            }
+        }
+    }
+};
+exports.NatsTransport = NatsTransport;
+exports.NatsTransport = NatsTransport = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)('MSG_CONFIG')),
+    __metadata("design:paramtypes", [Object])
+], NatsTransport);

package/dist/cjs/transports/redis.transport.d.ts

@@ -0,0 +1,16 @@
+import type { MessagingTransport, Subscription, SubscribeOptions } from '../transport.interface';
+import type { MessagingConfig } from '../messaging.config';
+export interface RedisTransportOptions {
+    url?: string;
+    host?: string;
+    port?: number;
+}
+export declare class RedisTransport implements MessagingTransport {
+    private config;
+    private pub;
+    private sub;
+    constructor(config: MessagingConfig);
+    connect(): Promise<void>;
+    publish(subject: string, payload: any): Promise<void>;
+    subscribe(subject: string, _options?: SubscribeOptions): Promise<Subscription>;
+}