@jsnw/nestjs-rabbitmq 1.0.0

package/dist/rabbitmq-explorer.service.js

@@ -0,0 +1,143 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitmqExplorerService = void 0;
+const common_1 = require("@nestjs/common");
+const rabbitmq_metadata_storage_1 = require("./rabbitmq-metadata-storage");
+const rabbitmq_helpers_1 = require("./rabbitmq.helpers");
+const rabbitmq_consts_1 = require("./rabbitmq.consts");
+let RabbitmqExplorerService = (() => {
+    let _classDecorators = [(0, common_1.Injectable)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var RabbitmqExplorerService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RabbitmqExplorerService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        discoveryService;
+        metadataScanner;
+        reflector;
+        instancesManager;
+        logger = new common_1.Logger(RabbitmqExplorerService.name);
+        constructor(discoveryService, metadataScanner, reflector, instancesManager) {
+            this.discoveryService = discoveryService;
+            this.metadataScanner = metadataScanner;
+            this.reflector = reflector;
+            this.instancesManager = instancesManager;
+        }
+        /**
+         * @return {Promise<void>}
+         */
+        async onApplicationBootstrap() {
+            await this.setupInfrastructure();
+            await this.setupSubscribers();
+        }
+        /**
+         * @return {Promise<void>}
+         * @private
+         */
+        async setupInfrastructure() {
+            const instances = this.instancesManager.getAllInstances();
+            for (const instance of instances) {
+                const metadata = rabbitmq_metadata_storage_1.RabbitmqMetadataStorage.getMetadata((0, rabbitmq_helpers_1.getInstanceToken)(instance.name));
+                if (!metadata || (metadata.exchanges.size === 0 && metadata.queues.size === 0))
+                    continue;
+                const exchanges = Array.from(metadata.exchanges), queues = Array.from(metadata.queues);
+                if (exchanges.length > 0)
+                    await Promise.all(exchanges.map(exchange => instance.declareExchange(exchange)));
+                if (queues.length > 0)
+                    await Promise.all(queues.map(queue => instance.declareQueue(queue)));
+            }
+        }
+        /**
+         * @return {Promise<void>}
+         * @private
+         */
+        async setupSubscribers() {
+            const wrappers = [
+                ...this.discoveryService.getProviders(),
+                ...this.discoveryService.getControllers()
+            ];
+            for (const wrapper of wrappers) {
+                const { instance } = wrapper;
+                if (!instance || typeof instance !== 'object')
+                    continue;
+                const prototype = Object.getPrototypeOf(instance);
+                if (!prototype)
+                    continue;
+                const methodNames = this.metadataScanner.getAllMethodNames(prototype);
+                for (const methodName of methodNames)
+                    await this.tryRegisterSubscriber(instance, methodName);
+            }
+        }
+        /**
+         * @param {any} instance
+         * @param {string} methodName
+         * @return {Promise<void>}
+         * @private
+         */
+        async tryRegisterSubscriber(instance, methodName) {
+            const methodRef = instance[methodName];
+            const subscriptionMetadata = this.reflector.get(rabbitmq_consts_1.RABBITMQ_SUBSCRIBE_METADATA_KEY, methodRef);
+            if (!subscriptionMetadata)
+                return;
+            const rabbitmqInstance = this.instancesManager.getInstance(subscriptionMetadata.instanceToken);
+            if (!rabbitmqInstance) {
+                this.logger.error(`Instance ${subscriptionMetadata.instanceName}" not found for subscriber ${instance.constructor.name}.${methodName}`);
+                return;
+            }
+            this.logger.log(`Registering subscriber: ${instance.constructor.name}.${methodName} -> ${subscriptionMetadata.queue.name}`);
+            await rabbitmqInstance.subscribe({
+                id: subscriptionMetadata.id,
+                queue: subscriptionMetadata.queue,
+                requeue: subscriptionMetadata.requeue,
+                concurrency: subscriptionMetadata.concurrency,
+                prefetchSize: subscriptionMetadata.prefetchSize,
+                prefetchCount: subscriptionMetadata.prefetchCount,
+                autoStart: subscriptionMetadata.autoStart,
+                validation: subscriptionMetadata.validation
+            }, { instance: instance, methodName: methodName });
+        }
+    };
+    return RabbitmqExplorerService = _classThis;
+})();
+exports.RabbitmqExplorerService = RabbitmqExplorerService;

package/dist/rabbitmq-instances-manager.js

@@ -0,0 +1,100 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitmqInstancesManager = void 0;
+const common_1 = require("@nestjs/common");
+const rabbitmq_helpers_1 = require("./rabbitmq.helpers");
+let RabbitmqInstancesManager = (() => {
+    let _classDecorators = [(0, common_1.Injectable)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var RabbitmqInstancesManager = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RabbitmqInstancesManager = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        /**
+         * @type {Map<string, Rabbitmq>}
+         * @private
+         */
+        instances = new Map();
+        /**
+         * @param {string | RabbitmqConstructorParams} token
+         * @param {Rabbitmq} instance
+         */
+        addInstance(token, instance) {
+            token = typeof token === 'string' ? token : (0, rabbitmq_helpers_1.getInstanceToken)(token);
+            if (this.instances.has(token))
+                return;
+            this.instances.set(token, instance);
+        }
+        /**
+         * @param {string | RabbitmqConstructorParams} token
+         * @return {Rabbitmq | null}
+         */
+        getInstance(token) {
+            token = typeof token === 'string' ? token : (0, rabbitmq_helpers_1.getInstanceToken)(token);
+            return this.instances.get(token) ?? null;
+        }
+        /**
+         * @param {string | RabbitmqConstructorParams} token
+         * @return {boolean}
+         */
+        hasInstance(token) {
+            token = typeof token === 'string' ? token : (0, rabbitmq_helpers_1.getInstanceToken)(token);
+            return this.instances.has(token);
+        }
+        /**
+         * @return {Rabbitmq[]}
+         */
+        getAllInstances() {
+            return Array.from(this.instances.values());
+        }
+        /**
+         * @return {Promise<void>}
+         */
+        async onApplicationShutdown() {
+            await Promise.allSettled(this.getAllInstances().map(instance => instance.close()));
+        }
+    };
+    return RabbitmqInstancesManager = _classThis;
+})();
+exports.RabbitmqInstancesManager = RabbitmqInstancesManager;

package/dist/rabbitmq-metadata-storage.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitmqMetadataStorage = void 0;
+const rabbitmq_helpers_1 = require("./rabbitmq.helpers");
+class RabbitmqMetadataStorage {
+    /**
+     * @type {Map<string, Metadata>}
+     * @private
+     */
+    static storage = new Map();
+    /**
+     * @param {string | RabbitmqConstructorParams} token
+     * @param {AddMetadataParams} metadata
+     */
+    static addMetadata(token, metadata = {}) {
+        token = typeof token === 'string' ? token : (0, rabbitmq_helpers_1.getInstanceToken)(token);
+        const { exchanges, queues } = metadata;
+        if (!this.storage.has(token))
+            this.storage.set(token, { exchanges: new Set(), queues: new Set() });
+        const metadataStorage = this.storage.get(token);
+        if (exchanges && exchanges.length > 0)
+            for (const exchange of exchanges)
+                metadataStorage.exchanges.add(exchange);
+        if (queues && queues.length > 0)
+            for (const queue of queues)
+                metadataStorage.queues.add(queue);
+    }
+    /**
+     * @param {string | RabbitmqConstructorParams} token
+     * @return {Metadata}
+     */
+    static getMetadata(token) {
+        token = typeof token === 'string' ? token : (0, rabbitmq_helpers_1.getInstanceToken)(token);
+        const metadataStorage = this.storage.get(token);
+        return metadataStorage ?? { exchanges: new Set(), queues: new Set() };
+    }
+}
+exports.RabbitmqMetadataStorage = RabbitmqMetadataStorage;

package/dist/rabbitmq.consts.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RABBITMQ_SUBSCRIBE_METADATA_KEY = exports.RABBITMQ_INSTANCE_TOKEN_PREFIX = exports.RABBITMQ_INSTANCE_DEFAULT_NAME = void 0;
+exports.RABBITMQ_INSTANCE_DEFAULT_NAME = 'default';
+exports.RABBITMQ_INSTANCE_TOKEN_PREFIX = 'RABBITMQ_INSTANCE_';
+exports.RABBITMQ_SUBSCRIBE_METADATA_KEY = Symbol('RABBITMQ_SUBSCRIBE_METADATA');

package/dist/rabbitmq.decorators.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitmqSubscribe = exports.InjectRabbitmq = void 0;
+const common_1 = require("@nestjs/common");
+const rabbitmq_consts_1 = require("./rabbitmq.consts");
+const rabbitmq_helpers_1 = require("./rabbitmq.helpers");
+/**
+ * @param {string} [instanceName = RABBITMQ_INSTANCE_DEFAULT_NAME]
+ * @return {PropertyDecorator & ParameterDecorator}
+ * @constructor
+ */
+const InjectRabbitmq = (instanceName = rabbitmq_consts_1.RABBITMQ_INSTANCE_DEFAULT_NAME) => (0, common_1.Inject)((0, rabbitmq_helpers_1.getInstanceToken)(instanceName));
+exports.InjectRabbitmq = InjectRabbitmq;
+/**
+ * @return {MethodDecorator}
+ * @constructor
+ */
+const RabbitmqSubscribe = (params) => {
+    return (target, key, descriptor) => {
+        (0, common_1.SetMetadata)(rabbitmq_consts_1.RABBITMQ_SUBSCRIBE_METADATA_KEY, {
+            instanceName: params.instanceName ?? rabbitmq_consts_1.RABBITMQ_INSTANCE_DEFAULT_NAME,
+            instanceToken: (0, rabbitmq_helpers_1.getInstanceToken)(params.instanceName ?? rabbitmq_consts_1.RABBITMQ_INSTANCE_DEFAULT_NAME),
+            id: params.id,
+            queue: params.queue,
+            autoStart: params.autoStart !== undefined ? params.autoStart : true,
+            concurrency: params.concurrency ?? 1,
+            prefetchSize: params.prefetchSize ?? 0,
+            prefetchCount: params.prefetchCount ?? 1,
+            requeue: params.requeue,
+            validation: params.validation ? {
+                schema: params.validation.schema,
+                onFail: params.validation.onFail ?? 'drop'
+            } : null
+        })(target, key, descriptor);
+        return descriptor;
+    };
+};
+exports.RabbitmqSubscribe = RabbitmqSubscribe;

package/dist/rabbitmq.helpers.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveInstanceName = resolveInstanceName;
+exports.getInstanceToken = getInstanceToken;
+const rabbitmq_consts_1 = require("./rabbitmq.consts");
+/**
+ * @param {string | RabbitmqConstructorParams} arg
+ * @return {string}
+ */
+function resolveInstanceName(arg) {
+    if (typeof arg === 'string')
+        return arg.toLowerCase();
+    if (arg.name && arg.name.trim() !== '')
+        return arg.name.trim().toLowerCase();
+    return `${arg.hostname}:${arg.port}/${(arg.vhost?.trim() ?? '').replace(/^\/|\/$/, '')}`.toLowerCase();
+}
+/**
+ * @param {string | RabbitmqConstructorParams} arg
+ * @return {string}
+ */
+function getInstanceToken(arg) {
+    if (typeof arg === 'string') {
+        // It is an instance name
+        return `${rabbitmq_consts_1.RABBITMQ_INSTANCE_TOKEN_PREFIX}${arg}`.toLowerCase();
+    }
+    return `${rabbitmq_consts_1.RABBITMQ_INSTANCE_TOKEN_PREFIX}${resolveInstanceName(arg)}`.toLowerCase();
+}

package/dist/rabbitmq.module.js

@@ -0,0 +1,93 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitmqModule = void 0;
+const common_1 = require("@nestjs/common");
+const rabbitmq_metadata_storage_1 = require("./rabbitmq-metadata-storage");
+const rabbitmq_core_module_1 = require("./rabbitmq-core.module");
+const rabbitmq_helpers_1 = require("./rabbitmq.helpers");
+let RabbitmqModule = (() => {
+    let _classDecorators = [(0, common_1.Module)({})];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var RabbitmqModule = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RabbitmqModule = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        /**
+         * @param {RabbitmqForRootParams} params
+         * @return {DynamicModule}
+         */
+        static forRoot(params) {
+            rabbitmq_metadata_storage_1.RabbitmqMetadataStorage.addMetadata(params, {
+                exchanges: params.exchanges ?? [],
+                queues: params.queues ?? []
+            });
+            return {
+                module: RabbitmqModule,
+                imports: [
+                    rabbitmq_core_module_1.RabbitmqCoreModule.forRoot(params)
+                ],
+                exports: [],
+                providers: []
+            };
+        }
+        /**
+         * @param {RabbitmqForFeatureParams} params
+         * @return {DynamicModule}
+         */
+        static forFeature(params) {
+            rabbitmq_metadata_storage_1.RabbitmqMetadataStorage.addMetadata((0, rabbitmq_helpers_1.getInstanceToken)((0, rabbitmq_helpers_1.resolveInstanceName)(params.name)), {
+                exchanges: params.exchanges ?? [],
+                queues: params.queues ?? []
+            });
+            return {
+                module: RabbitmqModule,
+                imports: [],
+                providers: [],
+                exports: []
+            };
+        }
+    };
+    return RabbitmqModule = _classThis;
+})();
+exports.RabbitmqModule = RabbitmqModule;

package/dist/rabbitmq.types.js

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

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './rabbitmq';
+export { RabbitmqModule } from './rabbitmq.module';
+export type { RabbitmqForRootParams, RabbitmqForFeatureParams, RabbitmqSubscribeDecoratorParams } from './rabbitmq.types';
+export { RabbitmqSubscribe, InjectRabbitmq } from './rabbitmq.decorators';
+export { type AsyncMessage } from 'rabbitmq-client';

package/dist/types/rabbitmq/index.d.ts

@@ -0,0 +1,3 @@
+export { Rabbitmq, type RabbitmqConstructorParams, type RabbitmqResponse, type RabbitmqSubscribeParams, type RabbitmqMessageValidation, type RabbitmqSubscriber, type RabbitmqPublishOptions } from './rabbitmq';
+export { RabbitmqExchange, type RabbitmqExchangeType, type RabbitmqExchangeDeclaration } from './rabbitmq-exchange';
+export { RabbitmqQueue, type RabbitmqQueueArguments, type RabbitmqQueueBinding, type RabbitmqQueueDeclaration } from './rabbitmq-queue';

package/dist/types/rabbitmq/rabbitmq-exchange.d.ts

@@ -0,0 +1,18 @@
+export type RabbitmqExchangeType = 'direct' | 'topic';
+export type RabbitmqExchangeDeclaration = {
+    name: string;
+    type: RabbitmqExchangeType;
+    durable?: boolean;
+    autoDelete?: boolean;
+};
+export declare class RabbitmqExchange {
+    readonly _$type: 'exchange';
+    readonly name: string;
+    readonly type: RabbitmqExchangeType;
+    readonly durable: boolean;
+    readonly autoDelete: boolean;
+    /**
+     * @param {RabbitmqExchangeDeclaration} declaration
+     */
+    constructor(declaration: RabbitmqExchangeDeclaration);
+}

package/dist/types/rabbitmq/rabbitmq-queue.d.ts

@@ -0,0 +1,49 @@
+import { type RabbitmqExchange } from './rabbitmq-exchange';
+export type RabbitmqQueueArguments = {
+    /** Per-Queue Message TTL https://www.rabbitmq.com/ttl.html#per-queue-message-ttl */
+    'x-message-ttl'?: number;
+    /** Queue Expiry https://www.rabbitmq.com/ttl.html#queue-ttl */
+    'x-expires'?: number;
+    /** https://www.rabbitmq.com/maxlength.html */
+    'x-max-length'?: number;
+    /** https://www.rabbitmq.com/maxlength.html */
+    'x-overflow'?: 'drop-head' | 'reject-publish' | 'reject-publish-dlx';
+    /** https://www.rabbitmq.com/priority.html */
+    'x-max-priority'?: number;
+    /** https://www.rabbitmq.com/quorum-queues.html
+     * https://www.rabbitmq.com/streams.html */
+    'x-queue-type'?: 'quorum' | 'classic' | 'stream';
+    [k: string]: any;
+};
+export type RabbitmqQueueBinding = {
+    exchange: RabbitmqExchange;
+    routingKeys?: string[];
+};
+export type RabbitmqQueueDeclaration = {
+    name: string;
+    deadLetterExchange?: RabbitmqExchange | null;
+    deadLetterRoutingKey?: string | null;
+    arguments?: RabbitmqQueueArguments;
+    durable?: boolean;
+    autoDelete?: boolean;
+    exclusive?: boolean;
+    bindings?: RabbitmqQueueBinding[];
+};
+export declare class RabbitmqQueue {
+    readonly _$type: 'queue';
+    readonly name: string;
+    readonly arguments: RabbitmqQueueArguments;
+    readonly durable: boolean;
+    readonly autoDelete: boolean;
+    readonly exclusive: boolean;
+    /** https://www.rabbitmq.com/dlx.html */
+    readonly deadLetterExchange: RabbitmqExchange | null;
+    /** https://www.rabbitmq.com/dlx.html */
+    readonly deadLetterRoutingKey: string | null;
+    private readonly _bindings;
+    get bindings(): Required<RabbitmqQueueBinding>[];
+    /**
+     * @param {RabbitmqQueueDeclaration} declaration
+     */
+    constructor(declaration: RabbitmqQueueDeclaration);
+}

package/dist/types/rabbitmq/rabbitmq.d.ts

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+import { type AsyncMessage, Connection, type Consumer, ConsumerStatus, Publisher } from 'rabbitmq-client';
+import { RabbitmqExchange } from './rabbitmq-exchange';
+import { RabbitmqQueue } from './rabbitmq-queue';
+import { Logger } from '@nestjs/common';
+import { Jsonifiable } from 'type-fest';
+export type RabbitmqConstructorParams = {
+    name: string;
+    /**
+     * The name that will be displayed in RabbitMQ management UI. By default - the same as the name
+     */
+    connectionName?: string;
+    hostname: string;
+    port: number;
+    username: string;
+    password: string;
+    vhost?: string;
+    connectionTimeout?: number;
+};
+export type RabbitmqResponse = 'ack' | 'drop' | 'requeue';
+export type RabbitmqMessageValidation = {
+    schema: z.ZodTypeAny;
+    onFail?: RabbitmqResponse;
+};
+export type RabbitmqSubscribeParams = {
+    queue: RabbitmqQueue;
+    requeue?: boolean;
+    concurrency?: number;
+    prefetchSize?: number;
+    prefetchCount?: number;
+    validation?: RabbitmqMessageValidation;
+} & ({
+    id: string;
+    autoStart: boolean;
+} | {
+    id?: never;
+    autoStart?: never;
+});
+export type RabbitmqSubscriber = {
+    instance: any;
+    methodName: string;
+} | ((data: any, message: AsyncMessage) => RabbitmqResponse | Promise<RabbitmqResponse>);
+export type RabbitmqPublishOptions = {
+    exchange: RabbitmqExchange;
+    routingKey: string;
+    ttlMs?: number;
+    durable?: boolean;
+} & ({
+    type: 'raw';
+    message: string | Buffer;
+} | {
+    type: 'json';
+    message: Jsonifiable;
+});
+export declare class Rabbitmq {
+    readonly name: string;
+    protected readonly logger: Logger;
+    protected readonly connection: Connection;
+    protected readonly exchanges: Map<string, RabbitmqExchange>;
+    protected readonly queues: Map<string, RabbitmqQueue>;
+    protected readonly consumers: Set<Consumer>;
+    protected readonly consumersById: Map<string, {
+        isStarted: boolean;
+        consumer: Consumer;
+    }>;
+    protected publisher: Publisher | null;
+    constructor(name: string, connection: Connection);
+    constructor(params: RabbitmqConstructorParams);
+    /**
+     * @param {RabbitmqExchange} exchange
+     * @returns {Promise<boolean>}
+     */
+    declareExchange(exchange: RabbitmqExchange): Promise<boolean>;
+    /**
+     * @param {RabbitmqQueue} queue
+     * @returns {Promise<boolean>}
+     */
+    declareQueue(queue: RabbitmqQueue): Promise<boolean>;
+    /**
+     * @param {RabbitmqQueue} queue
+     * @returns {Promise<void>}
+     * @protected
+     */
+    protected setupQueueBindings(queue: RabbitmqQueue): Promise<void>;
+    /**
+     * @param {RabbitmqSubscribeParams} params
+     * @param {RabbitmqSubscriber} subscriber
+     * @returns {Promise<void>}
+     */
+    subscribe(params: RabbitmqSubscribeParams, subscriber: RabbitmqSubscriber): Promise<void>;
+    /**
+     * @param {string} id
+     * @returns {void}
+     */
+    startSubscriber(id: string): void;
+    /**
+     * @returns {void}
+     */
+    startPendingSubscribers(): void;
+    /**
+     * @param {RabbitmqSubscribeParams} params
+     * @param {RabbitmqSubscriber} subscriber
+     * @param {AsyncMessage} message
+     * @returns {Promise<ConsumerStatus>}
+     * @private
+     */
+    private internalConsumer;
+    /**
+     * @param {RabbitmqPublishOptions} options
+     * @return {Promise<void>}
+     */
+    publish(options: RabbitmqPublishOptions): Promise<void>;
+    /**
+     * @param {RabbitmqResponse | string} response
+     * @return {ConsumerStatus}
+     * @protected
+     */
+    protected mapRabbitmqResponseToConsumerStatus(response: RabbitmqResponse | string): ConsumerStatus;
+    /**
+     * @return {Promise<void>}
+     */
+    close(): Promise<void>;
+}