@lokative/messaging 0.1.1 → 1.1.1

package/dist/cjs/index.d.ts

@@ -0,0 +1,9 @@
+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';
+export { NatsTransport, NatsTransportOptions } from './transports/nats.transport';
+export { KafkaTransport, KafkaTransportOptions } from './transports/kafka.transport';
+export { RedisTransport, RedisTransportOptions } from './transports/redis.transport';

package/dist/cjs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisTransport = exports.KafkaTransport = exports.NatsTransport = 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; } });
+var nats_transport_1 = require("./transports/nats.transport");
+Object.defineProperty(exports, "NatsTransport", { enumerable: true, get: function () { return nats_transport_1.NatsTransport; } });
+var kafka_transport_1 = require("./transports/kafka.transport");
+Object.defineProperty(exports, "KafkaTransport", { enumerable: true, get: function () { return kafka_transport_1.KafkaTransport; } });
+var redis_transport_1 = require("./transports/redis.transport");
+Object.defineProperty(exports, "RedisTransport", { enumerable: true, get: function () { return redis_transport_1.RedisTransport; } });

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/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>;
+}

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

@@ -0,0 +1,71 @@
+"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.RedisTransport = void 0;
+const common_1 = require("@nestjs/common");
+const redis_1 = require("redis");
+let RedisTransport = class RedisTransport {
+    config;
+    pub;
+    sub;
+    constructor(config) {
+        this.config = config;
+    }
+    async connect() {
+        const opts = this.config.transportOptions;
+        const url = opts.url ?? `redis://${opts.host ?? 'localhost'}:${opts.port ?? 6379}`;
+        this.pub = (0, redis_1.createClient)({ url });
+        this.sub = this.pub.duplicate();
+        await this.pub.connect();
+        await this.sub.connect();
+    }
+    async publish(subject, payload) {
+        await this.pub.publish(subject, JSON.stringify(payload));
+    }
+    async subscribe(subject, _options) {
+        const buffer = [];
+        let waiting = null;
+        await this.sub.subscribe(subject, (message, channel) => {
+            const envelope = {
+                subject: channel,
+                data: JSON.parse(message),
+                ack: () => { }, // redis pub/sub has no ack mechanism
+                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.RedisTransport = RedisTransport;
+exports.RedisTransport = RedisTransport = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)('MSG_CONFIG')),
+    __metadata("design:paramtypes", [Object])
+], RedisTransport);

package/dist/esm/index.d.ts

@@ -0,0 +1,9 @@
+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';
+export { NatsTransport, NatsTransportOptions } from './transports/nats.transport';
+export { KafkaTransport, KafkaTransportOptions } from './transports/kafka.transport';
+export { RedisTransport, RedisTransportOptions } from './transports/redis.transport';

package/dist/esm/index.js

@@ -0,0 +1,8 @@
+export { 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';
+export { NatsTransport } from './transports/nats.transport';
+export { KafkaTransport } from './transports/kafka.transport';
+export { RedisTransport } from './transports/redis.transport';

package/dist/esm/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/esm/messaging.config.js

@@ -0,0 +1 @@
+export {};

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

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

package/dist/esm/messaging.decorator.js

@@ -0,0 +1,16 @@
+export function Incoming(subject) {
+    return (target, key) => {
+        Reflect.defineMetadata("msg:incoming", { subject }, target[key]);
+    };
+}
+export 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/esm/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/esm/messaging.module.js

@@ -0,0 +1,31 @@
+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;
+import { Module } from "@nestjs/common";
+import { DiscoveryModule } from "@nestjs/core";
+import { MESSAGING_TRANSPORT } from "./transport.interface";
+import { MessagingPublisher } from "./messaging.publisher";
+import { MessagingConsumerRegistry } from "./messaging.registry";
+let MessagingModule = MessagingModule_1 = class MessagingModule {
+    static register(config) {
+        return {
+            module: MessagingModule_1,
+            imports: [DiscoveryModule],
+            providers: [
+                { provide: "MSG_CONFIG", useValue: config },
+                { provide: MESSAGING_TRANSPORT, useClass: config.transport },
+                MessagingPublisher,
+                MessagingConsumerRegistry,
+            ],
+            exports: [MessagingPublisher],
+        };
+    }
+};
+MessagingModule = MessagingModule_1 = __decorate([
+    Module({})
+], MessagingModule);
+export { MessagingModule };

package/dist/esm/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/esm/messaging.publisher.js

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

package/dist/esm/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/esm/messaging.registry.js

@@ -0,0 +1,64 @@
+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); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { DiscoveryService } from "@nestjs/core/discovery";
+import { MESSAGING_TRANSPORT } from "./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();
+            }
+        }
+    }
+};
+MessagingConsumerRegistry = __decorate([
+    Injectable(),
+    __param(0, Inject(MESSAGING_TRANSPORT)),
+    __param(2, Inject("MSG_CONFIG")),
+    __metadata("design:paramtypes", [Object, DiscoveryService, Object])
+], MessagingConsumerRegistry);
+export { MessagingConsumerRegistry };

package/dist/esm/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/esm/transport.interface.js

@@ -0,0 +1 @@
+export const MESSAGING_TRANSPORT = 'MESSAGING_TRANSPORT';

package/dist/esm/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/esm/transports/kafka.transport.js

@@ -0,0 +1,79 @@
+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); }
+};
+import { Inject, Injectable } from '@nestjs/common';
+import { Kafka } from 'kafkajs';
+let KafkaTransport = class KafkaTransport {
+    config;
+    kafka;
+    producer;
+    constructor(config) {
+        this.config = config;
+    }
+    async connect() {
+        const opts = this.config.transportOptions;
+        this.kafka = new 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 };
+    }
+};
+KafkaTransport = __decorate([
+    Injectable(),
+    __param(0, Inject('MSG_CONFIG')),
+    __metadata("design:paramtypes", [Object])
+], KafkaTransport);
+export { KafkaTransport };

package/dist/esm/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/esm/transports/nats.transport.js

@@ -0,0 +1,87 @@
+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); }
+};
+import { Inject, Injectable } from '@nestjs/common';
+import { connect, consumerOpts } from 'nats';
+let NatsTransport = class NatsTransport {
+    config;
+    nc;
+    js;
+    jsm;
+    constructor(config) {
+        this.config = config;
+    }
+    async connect() {
+        const opts = this.config.transportOptions;
+        this.nc = await 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 = 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;
+                }
+            }
+        }
+    }
+};
+NatsTransport = __decorate([
+    Injectable(),
+    __param(0, Inject('MSG_CONFIG')),
+    __metadata("design:paramtypes", [Object])
+], NatsTransport);
+export { NatsTransport };

package/dist/esm/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>;
+}

package/dist/esm/transports/redis.transport.js

@@ -0,0 +1,68 @@
+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); }
+};
+import { Inject, Injectable } from '@nestjs/common';
+import { createClient } from 'redis';
+let RedisTransport = class RedisTransport {
+    config;
+    pub;
+    sub;
+    constructor(config) {
+        this.config = config;
+    }
+    async connect() {
+        const opts = this.config.transportOptions;
+        const url = opts.url ?? `redis://${opts.host ?? 'localhost'}:${opts.port ?? 6379}`;
+        this.pub = createClient({ url });
+        this.sub = this.pub.duplicate();
+        await this.pub.connect();
+        await this.sub.connect();
+    }
+    async publish(subject, payload) {
+        await this.pub.publish(subject, JSON.stringify(payload));
+    }
+    async subscribe(subject, _options) {
+        const buffer = [];
+        let waiting = null;
+        await this.sub.subscribe(subject, (message, channel) => {
+            const envelope = {
+                subject: channel,
+                data: JSON.parse(message),
+                ack: () => { }, // redis pub/sub has no ack mechanism
+                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 };
+    }
+};
+RedisTransport = __decorate([
+    Injectable(),
+    __param(0, Inject('MSG_CONFIG')),
+    __metadata("design:paramtypes", [Object])
+], RedisTransport);
+export { RedisTransport };

package/package.json

@@ -1,21 +1,23 @@
 {
   "name": "@lokative/messaging",
-  "version": "0.1.1",
+  "version": "1.1.1",
   "description": "",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/cjs/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/cjs/index.js"
     }
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc -p tsconfig.esm.json && tsc -p tsconfig.cjs.json",
     "test": "vitest run",
     "prepublishOnly": "npm run build"
   },