@diia-inhouse/diia-queue 13.3.4 → 14.0.10

package/dist/providers/rabbitmq/amqpAsserter.js

@@ -1,417 +1,370 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import { Arguments } from "../../interfaces/providers/rabbitmq/index.js";
+import { AmqpConnectionEventNames } from "../../interfaces/providers/rabbitmq/amqpConnection.js";
+import { QueueTypes } from "../../interfaces/messageBrokerServiceConfig.js";
+import "../../interfaces/index.js";
+import constants_default from "../../constants.js";
+import { readFile } from "node:fs/promises";
+//#region src/providers/rabbitmq/amqpAsserter.ts
+var AmqpAsserter = class AmqpAsserter {
+	connection;
+	logger;
+	declareOptions;
+	static PrefixAlternate = "Alternate";
+	defaultExchangeType = "topic";
+	defaultQueueOptions = { durable: true };
+	defaultExchangeOptions = {
+		durable: true,
+		autoDelete: false
+	};
+	defaultDeclareOptions = {
+		assertQueues: true,
+		assertExchanges: true
+	};
+	channel;
+	channelName = "asserterChannel";
+	constructor(connection, logger, declareOptions = {}) {
+		this.connection = connection;
+		this.logger = logger;
+		this.declareOptions = declareOptions;
+		declareOptions.assertQueues ??= this.defaultDeclareOptions.assertQueues;
+		declareOptions.assertExchanges ??= this.defaultDeclareOptions.assertExchanges;
+	}
+	async init(exchangesOptions = [], queuesOptions = []) {
+		if (!this.channel) {
+			await this.initChannel();
+			this.connection.on(AmqpConnectionEventNames.Ready, async () => {
+				await this.initChannel();
+			});
+		}
+		await this.assertExchanges(exchangesOptions);
+		await this.declareQueues(queuesOptions, exchangesOptions);
+	}
+	async declareQueuesByJSON(declarationConfigPath) {
+		const { exchangesOptions, queuesOptions } = await this.readConfig(declarationConfigPath);
+		await this.declareQueues(queuesOptions, exchangesOptions);
+	}
+	async declareQueues(queuesOptions = [], exchangesOptions = []) {
+		for (const queueOptions of queuesOptions) {
+			const { name: queueName, redeclareOptions: { redeclare } = {} } = queueOptions;
+			if (redeclare) try {
+				await this.redeclareQueue(queueOptions, exchangesOptions);
+			} catch (err) {
+				this.logger.error(`Error while redeclaring queue ${queueName}`, { err });
+				throw err;
+			}
+			else await this.assertQueue(queueOptions);
+		}
+	}
+	async redeclareQueue(queueOptions, exchangesOptions) {
+		const { bindTo = [], redeclareOptions = {} } = queueOptions;
+		const { redeclare } = redeclareOptions;
+		if (!redeclare) return false;
+		const redeclareQueueOptions = this.prepareRedeclareQueueOptions(queueOptions, redeclareOptions);
+		const { name: queueName } = redeclareQueueOptions;
+		this.logger.info(`Queue ${queueName} is being to be redeclared`, { options: redeclareQueueOptions });
+		const alternateExchangesOptions = await this.assertAlternateExchanges(redeclareQueueOptions, exchangesOptions);
+		const { name: alternateQueueName } = await this.assertAlternateQueue(redeclareQueueOptions, alternateExchangesOptions);
+		await this.unbindQueueFromExchanges({
+			bindTo: [],
+			name: queueName,
+			unbindFrom: bindTo.map(({ exchangeName, routingKey }) => ({
+				routingKey,
+				exchangeName,
+				unbind: true
+			}))
+		});
+		const { name: tempQueueName, bindTo: tempBindTo } = await this.assertTemporaryQueue(redeclareQueueOptions);
+		await this.transferMessageBetweenQueues(queueName, tempQueueName);
+		try {
+			await this.deleteQueue(queueName);
+		} catch (err) {
+			if (!(err instanceof Error)) throw err;
+			if (err.message.includes("NOT_FOUND - no queue")) {
+				await this.deleteQueues([alternateQueueName, tempQueueName]);
+				await this.deleteExchanges(Object.values(alternateExchangesOptions));
+			}
+			return false;
+		}
+		await this.assertQueue(redeclareQueueOptions);
+		await this.unbindQueueFromExchanges({
+			bindTo: [],
+			name: tempQueueName,
+			unbindFrom: tempBindTo.map(({ exchangeName, routingKey }) => ({
+				routingKey,
+				exchangeName,
+				unbind: true
+			}))
+		});
+		await this.transferMessageBetweenQueues(tempQueueName, queueName);
+		await this.transferMessageBetweenQueues(alternateQueueName, queueName);
+		await this.deleteQueue(tempQueueName);
+		await this.deleteQueue(alternateQueueName);
+		await this.deleteExchanges(Object.values(alternateExchangesOptions));
+		this.logger.info(`Queue ${queueName} has been redeclared successfully`);
+		return true;
+	}
+	async transferMessageBetweenQueues(sourceQueueName, destinationQueueName) {
+		this.logger.info(`Transferring messages from ${sourceQueueName} to ${destinationQueueName} is being started`);
+		let messageCount = 0;
+		const channel = await this.connection.createChannel();
+		while (true) {
+			let message;
+			try {
+				const gotMessage = await channel.get(sourceQueueName, { noAck: true });
+				if (!gotMessage) break;
+				message = gotMessage;
+				messageCount += 1;
+			} catch (err) {
+				this.logger.error(`Error while getting messages from ${sourceQueueName}`, {
+					err,
+					messageCount
+				});
+				throw err;
+			}
+			try {
+				channel.sendToQueue(destinationQueueName, message.content, message.properties);
+				this.logger.debug(`Message ${messageCount} has been transferred from ${sourceQueueName} to ${destinationQueueName}`);
+			} catch (err) {
+				this.logger.error(`Error while publishing messages to ${destinationQueueName}`, {
+					err,
+					messageCount
+				});
+				throw err;
+			}
+		}
+		await channel.close();
+		this.logger.info(`Transferring messages from ${sourceQueueName} to ${destinationQueueName} has been finished`, { messageCount });
+	}
+	async deleteExchanges(exchangesOptions) {
+		const result = {};
+		for (const exchangeOptions of exchangesOptions) {
+			const { name: exchangeName } = exchangeOptions;
+			result[exchangeName] = await this.deleteExchange(exchangeName);
+		}
+		return result;
+	}
+	async deleteExchange(exchangeName) {
+		try {
+			const result = await this.channel?.deleteExchange(exchangeName);
+			this.logger.info(`Exchange ${exchangeName} has been deleted`);
+			return result;
+		} catch (err) {
+			this.logger.error(`Error while deleting an exchange`, {
+				exchangeName,
+				err
+			});
+			throw err;
+		}
+	}
+	async deleteQueues(queueNames) {
+		const result = {};
+		for (const queueName of queueNames) result[queueName] = await this.deleteQueue(queueName);
+		return result;
+	}
+	async deleteQueue(queueName) {
+		try {
+			const result = await this.channel?.deleteQueue(queueName);
+			this.logger.info(`Queue ${queueName} has been deleted`, {
+				queueName,
+				result
+			});
+			return result;
+		} catch (err) {
+			this.logger.error(`Error while deleting a queue`, {
+				queueName,
+				err
+			});
+			throw err;
+		}
+	}
+	async assertQueues(queueOptions) {
+		const result = {};
+		for (const queueOption of queueOptions) result[queueOption.name] = await this.assertQueue(queueOption);
+		return result;
+	}
+	async assertQueue(queueOptions) {
+		const { bindTo, declare, name: queueName, unbindFrom = [], type = QueueTypes.Quorum, options = this.defaultQueueOptions } = queueOptions;
+		const shouldDeclare = declare ?? this.declareOptions.assertQueues;
+		options.arguments = {
+			...options.arguments,
+			...type === QueueTypes.Quorum ? { [Arguments.queueType]: type } : {}
+		};
+		try {
+			if (shouldDeclare) {
+				const result = await this.channel?.assertQueue(queueName, options);
+				this.logger.info(`Queue ${queueName} has been declared`, {
+					queueOptions,
+					result
+				});
+				for (const bindOptions of bindTo) await this.bindQueueToExchange(queueName, bindOptions);
+				for (const unbindOption of unbindFrom) await this.unbindQueueFromExchange(queueName, unbindOption);
+				return result;
+			}
+		} catch (err) {
+			this.logger.error(`Error while assert queue`, {
+				queueName,
+				err
+			});
+			throw err;
+		}
+	}
+	async assertExchanges(exchangeOptions) {
+		const result = {};
+		for (const exchangeOption of exchangeOptions) result[exchangeOption.name] = await this.assertExchange(exchangeOption);
+		return result;
+	}
+	async assertExchange(exchangeOptions) {
+		const { name, delayed, declare, bindTo = [], type = this.defaultExchangeType, options = this.defaultExchangeOptions } = exchangeOptions;
+		options.arguments = {
+			...options.arguments,
+			...delayed ? { [Arguments.delayedType]: "topic" } : {}
+		};
+		const exchangeType = delayed ? "x-delayed-message" : type;
+		const shouldDeclare = declare ?? this.declareOptions.assertExchanges;
+		try {
+			if (shouldDeclare) {
+				const result = await this.channel?.assertExchange(name, exchangeType, options);
+				this.logger.info(`Exchange ${name} has been declared`, {
+					exchangeOptions,
+					result
+				});
+				await this.bindExchangeToExchanges(name, bindTo);
+				return result;
+			}
+		} catch (err) {
+			this.logger.error(`Error while assert exchange`, {
+				name,
+				err
+			});
+			throw err;
+		}
+	}
+	async unbindQueueFromExchanges(queueOptions) {
+		const { name: queueName, unbindFrom = [] } = queueOptions;
+		for (const unbindOption of unbindFrom) await this.unbindQueueFromExchange(queueName, unbindOption);
+	}
+	async bindQueueToExchange(queueName, bindOptions) {
+		const { bind, exchangeName, routingKey = constants_default.DEFAULT_ROUTING_KEY } = bindOptions;
+		const shouldBind = bind ?? this.declareOptions.assertQueues;
+		try {
+			if (shouldBind) {
+				const result = await this.channel?.bindQueue(queueName, exchangeName, routingKey);
+				this.logger.info(`Queue [${queueName}] has been bound with exchange [${exchangeName}] by routing key [${routingKey}]`);
+				return result;
+			}
+		} catch (err) {
+			this.logger.error(`Error while binding queue [${queueName}] to exchange [${exchangeName}] by routing key [${routingKey}]`, { err });
+			throw err;
+		}
+	}
+	async bindExchangeToExchanges(exchangeName, bindTo) {
+		for (const bindOption of bindTo) await this.bindExchangeToExchange(exchangeName, bindOption);
+	}
+	async bindExchangeToExchange(exchangeName, bindOptions) {
+		const { bind, exchangeName: relatedExchangeName, routingKey = constants_default.DEFAULT_ROUTING_KEY } = bindOptions;
+		const shouldBind = bind ?? this.declareOptions.assertExchanges;
+		try {
+			if (shouldBind) {
+				const result = await this.channel?.bindExchange(exchangeName, relatedExchangeName, routingKey);
+				this.logger.info(`Exchange [${exchangeName}] has been bound with exchange [${relatedExchangeName}] by routing key [${routingKey}]`);
+				return result;
+			}
+		} catch (err) {
+			this.logger.error(`Error while binding exchange [${exchangeName}] to exchange [${relatedExchangeName}] by routing key [${routingKey}]`, { err });
+			throw err;
+		}
+	}
+	async unbindQueueFromExchange(queueName, unbindOptions) {
+		const { unbind, exchangeName, routingKey = constants_default.DEFAULT_ROUTING_KEY } = unbindOptions;
+		try {
+			if (unbind) {
+				const result = await this.channel?.unbindQueue(queueName, exchangeName, routingKey);
+				this.logger.info(`Queue [${queueName}] has been unbound from exchange [${exchangeName}] by routing key [${routingKey}]`);
+				return result;
+			}
+		} catch (err) {
+			this.logger.error(`Error while unbinding queue [${queueName}] from exchange [${exchangeName}] by routing key [${routingKey}]`, { err });
+			throw err;
+		}
+	}
+	async disconnect() {
+		await this.channel?.close();
+		this.connection.removeAllListeners(AmqpConnectionEventNames.Ready);
+		await this.connection.closeConnection();
+	}
+	async initChannel() {
+		this.channel = await this.connection.createChannel(this.channelName);
+	}
+	async readConfig(declarationConfigPath) {
+		const data = await readFile(declarationConfigPath, { encoding: "utf8" });
+		return JSON.parse(data);
+	}
+	async assertTemporaryQueue(queueOptions) {
+		const tempQueueOptions = this.prepareTemporaryQueueOptions(queueOptions);
+		await this.assertQueue(tempQueueOptions);
+		return tempQueueOptions;
+	}
+	async assertAlternateExchanges(queueOptions, exchangesOptions) {
+		const alternateExchangesOptions = this.prepareAlternateExchangesOptions(queueOptions, exchangesOptions);
+		await this.assertExchanges(Object.values(alternateExchangesOptions));
+		return alternateExchangesOptions;
+	}
+	async assertAlternateQueue(queueOptions, alternateExchangesOptions) {
+		const alternateQueueOptions = this.prepareAlternateQueueOptions(queueOptions, alternateExchangesOptions);
+		await this.assertQueue(alternateQueueOptions);
+		return alternateQueueOptions;
+	}
+	prepareRedeclareQueueOptions(queueOptions, redeclareQueueOptions) {
+		return {
+			...queueOptions,
+			...redeclareQueueOptions
+		};
+	}
+	prepareTemporaryQueueOptions(queueOptions) {
+		return {
+			...queueOptions,
+			name: `${queueOptions.name}Temporary`
+		};
+	}
+	prepareAlternateExchangesOptions(queueOptions, exchangesOptions) {
+		const result = {};
+		if (exchangesOptions.length === 0) return result;
+		const exchangesOptionsMap = new Map(exchangesOptions.map((exchangeOptions) => [exchangeOptions.name, exchangeOptions]));
+		for (const bindOptions of queueOptions.bindTo) {
+			const { exchangeName, bind } = bindOptions;
+			if (!bind) continue;
+			const exchangeOptions = exchangesOptionsMap.get(exchangeName);
+			if (!exchangeOptions) throw new Error(`Alternate exchange options could not be defined for unknown exchange [${exchangeName}]`);
+			result[exchangeName] = this.prepareAlternateExchangeOptions(exchangeOptions);
+		}
+		return result;
+	}
+	prepareAlternateExchangeOptions(exchangeOptions) {
+		const { name: exchangeName } = exchangeOptions;
+		return {
+			...exchangeOptions,
+			declare: true,
+			name: `${exchangeName}${AmqpAsserter.PrefixAlternate}`
+		};
+	}
+	prepareAlternateQueueOptions(queueOptions, alternateExchangesOptions) {
+		const { name: queueName, bindTo = [] } = queueOptions;
+		return {
+			...queueOptions,
+			name: `${queueName}${AmqpAsserter.PrefixAlternate}`,
+			bindTo: this.prepareAlternateBindToQueueOption(bindTo, alternateExchangesOptions)
+		};
+	}
+	prepareAlternateBindToQueueOption(bindTo, alternateExchangesOptions) {
+		return bindTo.filter(({ exchangeName }) => exchangeName in alternateExchangesOptions).map(({ exchangeName, routingKey }) => {
+			const { name: alternateExchangeName } = alternateExchangesOptions[exchangeName];
+			return {
+				bind: true,
+				routingKey,
+				exchangeName: alternateExchangeName
+			};
+		});
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AmqpAsserter = void 0;
-const promises_1 = require("node:fs/promises");
-const constants_1 = __importDefault(require("../../constants"));
-const interfaces_1 = require("../../interfaces");
-const messageBrokerServiceConfig_1 = require("../../interfaces/messageBrokerServiceConfig");
-class AmqpAsserter {
-    connection;
-    logger;
-    declareOptions;
-    static PrefixAlternate = 'Alternate';
-    defaultExchangeType = messageBrokerServiceConfig_1.ExchangeType.Topic;
-    defaultQueueOptions = { durable: true };
-    defaultExchangeOptions = {
-        durable: true,
-        autoDelete: false,
-    };
-    defaultDeclareOptions = {
-        assertQueues: true,
-        assertExchanges: true,
-    };
-    channel;
-    channelName = 'asserterChannel';
-    constructor(connection, logger, declareOptions = {}) {
-        this.connection = connection;
-        this.logger = logger;
-        this.declareOptions = declareOptions;
-        declareOptions.assertQueues ??= this.defaultDeclareOptions.assertQueues;
-        declareOptions.assertExchanges ??= this.defaultDeclareOptions.assertExchanges;
-    }
-    async init(exchangesOptions = [], queuesOptions = []) {
-        if (!this.channel) {
-            await this.initChannel();
-            this.connection.on(interfaces_1.AmqpConnectionEventNames.Ready, async () => {
-                // in case if reconnect happened
-                await this.initChannel();
-            });
-        }
-        await this.assertExchanges(exchangesOptions);
-        await this.declareQueues(queuesOptions, exchangesOptions);
-    }
-    async declareQueuesByJSON(declarationConfigPath) {
-        const { exchangesOptions, queuesOptions } = await this.readConfig(declarationConfigPath);
-        await this.declareQueues(queuesOptions, exchangesOptions);
-    }
-    async declareQueues(queuesOptions = [], exchangesOptions = []) {
-        for await (const queueOptions of queuesOptions) {
-            const { name: queueName, redeclareOptions: { redeclare } = {} } = queueOptions;
-            if (redeclare) {
-                try {
-                    await this.redeclareQueue(queueOptions, exchangesOptions);
-                }
-                catch (err) {
-                    this.logger.error(`Error while redeclaring queue ${queueName}`, { err });
-                    throw err;
-                }
-            }
-            else {
-                await this.assertQueue(queueOptions);
-            }
-        }
-    }
-    async redeclareQueue(queueOptions, exchangesOptions) {
-        const { bindTo = [], redeclareOptions = {} } = queueOptions;
-        const { redeclare } = redeclareOptions;
-        if (!redeclare) {
-            return false;
-        }
-        // prepare redeclare queue options
-        const redeclareQueueOptions = this.prepareRedeclareQueueOptions(queueOptions, redeclareOptions);
-        const { name: queueName } = redeclareQueueOptions;
-        this.logger.info(`Queue ${queueName} is being to be redeclared`, { options: redeclareQueueOptions });
-        // assert alternate exchanges
-        const alternateExchangesOptions = await this.assertAlternateExchanges(redeclareQueueOptions, exchangesOptions);
-        // assert alternate queue
-        const { name: alternateQueueName } = await this.assertAlternateQueue(redeclareQueueOptions, alternateExchangesOptions);
-        // unbind old queue
-        await this.unbindQueueFromExchanges({
-            bindTo: [],
-            name: queueName,
-            unbindFrom: bindTo.map(({ exchangeName, routingKey }) => ({
-                routingKey,
-                exchangeName,
-                unbind: true,
-            })),
-        });
-        // assert temporary queue
-        const { name: tempQueueName, bindTo: tempBindTo } = await this.assertTemporaryQueue(redeclareQueueOptions);
-        // transfer messages from old queue to temporary queue
-        await this.transferMessageBetweenQueues(queueName, tempQueueName);
-        try {
-            // delete old queue
-            await this.deleteQueue(queueName);
-        }
-        catch (err) {
-            if (!(err instanceof Error)) {
-                throw err;
-            }
-            if (err.message.includes('NOT_FOUND - no queue')) {
-                await this.deleteQueues([alternateQueueName, tempQueueName]);
-                await this.deleteExchanges(Object.values(alternateExchangesOptions));
-            }
-            return false;
-        }
-        // assert new queue
-        await this.assertQueue(redeclareQueueOptions);
-        // unbind temp queue
-        await this.unbindQueueFromExchanges({
-            bindTo: [],
-            name: tempQueueName,
-            unbindFrom: tempBindTo.map(({ exchangeName, routingKey }) => ({
-                routingKey,
-                exchangeName,
-                unbind: true,
-            })),
-        });
-        // transfer messages from temporary queue to new queue
-        await this.transferMessageBetweenQueues(tempQueueName, queueName);
-        // transfer messages from alternate queue to new queue
-        await this.transferMessageBetweenQueues(alternateQueueName, queueName);
-        // delete temporary queue
-        await this.deleteQueue(tempQueueName);
-        // delete alternate queue
-        await this.deleteQueue(alternateQueueName);
-        // delete alternate exchanges
-        await this.deleteExchanges(Object.values(alternateExchangesOptions));
-        this.logger.info(`Queue ${queueName} has been redeclared successfully`);
-        return true;
-    }
-    async transferMessageBetweenQueues(sourceQueueName, destinationQueueName) {
-        this.logger.info(`Transferring messages from ${sourceQueueName} to ${destinationQueueName} is being started`);
-        let messageCount = 0;
-        const channel = await this.connection.createChannel();
-        while (true) {
-            let message;
-            try {
-                const gotMessage = await channel.get(sourceQueueName, { noAck: true });
-                if (!gotMessage) {
-                    break;
-                }
-                message = gotMessage;
-                messageCount += 1;
-            }
-            catch (err) {
-                this.logger.error(`Error while getting messages from ${sourceQueueName}`, { err, messageCount });
-                throw err;
-            }
-            try {
-                channel.sendToQueue(destinationQueueName, message.content, message.properties);
-                this.logger.debug(`Message ${messageCount} has been transferred from ${sourceQueueName} to ${destinationQueueName}`);
-            }
-            catch (err) {
-                this.logger.error(`Error while publishing messages to ${destinationQueueName}`, { err, messageCount });
-                throw err;
-            }
-        }
-        await channel.close();
-        this.logger.info(`Transferring messages from ${sourceQueueName} to ${destinationQueueName} has been finished`, {
-            messageCount,
-        });
-    }
-    async deleteExchanges(exchangesOptions) {
-        const result = {};
-        for await (const exchangeOptions of exchangesOptions) {
-            const { name: exchangeName } = exchangeOptions;
-            result[exchangeName] = await this.deleteExchange(exchangeName);
-        }
-        return result;
-    }
-    async deleteExchange(exchangeName) {
-        try {
-            const result = await this.channel?.deleteExchange(exchangeName);
-            this.logger.info(`Exchange ${exchangeName} has been deleted`);
-            return result;
-        }
-        catch (err) {
-            this.logger.error(`Error while deleting an exchange`, { exchangeName, err });
-            throw err;
-        }
-    }
-    async deleteQueues(queueNames) {
-        const result = {};
-        for (const queueName of queueNames) {
-            result[queueName] = await this.deleteQueue(queueName);
-        }
-        return result;
-    }
-    async deleteQueue(queueName) {
-        try {
-            const result = await this.channel?.deleteQueue(queueName);
-            this.logger.info(`Queue ${queueName} has been deleted`, { queueName, result });
-            return result;
-        }
-        catch (err) {
-            this.logger.error(`Error while deleting a queue`, { queueName, err });
-            throw err;
-        }
-    }
-    async assertQueues(queueOptions) {
-        const result = {};
-        for await (const queueOption of queueOptions) {
-            result[queueOption.name] = await this.assertQueue(queueOption);
-        }
-        return result;
-    }
-    async assertQueue(queueOptions) {
-        const { bindTo, declare, name: queueName, unbindFrom = [], type = messageBrokerServiceConfig_1.QueueTypes.Quorum, options = this.defaultQueueOptions, } = queueOptions;
-        const shouldDeclare = declare ?? this.declareOptions.assertQueues;
-        options.arguments = {
-            ...options.arguments,
-            ...(type === messageBrokerServiceConfig_1.QueueTypes.Quorum
-                ? {
-                    [interfaces_1.Arguments.queueType]: type,
-                }
-                : {}),
-        };
-        try {
-            if (shouldDeclare) {
-                const result = await this.channel?.assertQueue(queueName, options);
-                this.logger.info(`Queue ${queueName} has been declared`, { queueOptions, result });
-                for await (const bindOptions of bindTo) {
-                    await this.bindQueueToExchange(queueName, bindOptions);
-                }
-                for await (const unbindOption of unbindFrom) {
-                    await this.unbindQueueFromExchange(queueName, unbindOption);
-                }
-                return result;
-            }
-        }
-        catch (err) {
-            this.logger.error(`Error while assert queue`, { queueName, err });
-            throw err;
-        }
-    }
-    async assertExchanges(exchangeOptions) {
-        const result = {};
-        for await (const exchangeOption of exchangeOptions) {
-            result[exchangeOption.name] = await this.assertExchange(exchangeOption);
-        }
-        return result;
-    }
-    async assertExchange(exchangeOptions) {
-        const { name, delayed, declare, bindTo = [], type = this.defaultExchangeType, options = this.defaultExchangeOptions, } = exchangeOptions;
-        options.arguments = {
-            ...options.arguments,
-            ...(delayed ? { [interfaces_1.Arguments.delayedType]: messageBrokerServiceConfig_1.ExchangeType.Topic } : {}),
-        };
-        const exchangeType = delayed ? messageBrokerServiceConfig_1.ExchangeType.XDelayedMessage : type;
-        const shouldDeclare = declare ?? this.declareOptions.assertExchanges;
-        try {
-            if (shouldDeclare) {
-                const result = await this.channel?.assertExchange(name, exchangeType, options);
-                this.logger.info(`Exchange ${name} has been declared`, { exchangeOptions, result });
-                await this.bindExchangeToExchanges(name, bindTo);
-                return result;
-            }
-        }
-        catch (err) {
-            this.logger.error(`Error while assert exchange`, { name, err });
-            throw err;
-        }
-    }
-    async unbindQueueFromExchanges(queueOptions) {
-        const { name: queueName, unbindFrom = [] } = queueOptions;
-        for await (const unbindOption of unbindFrom) {
-            await this.unbindQueueFromExchange(queueName, unbindOption);
-        }
-    }
-    async bindQueueToExchange(queueName, bindOptions) {
-        const { bind, exchangeName, routingKey = constants_1.default.DEFAULT_ROUTING_KEY } = bindOptions;
-        const shouldBind = bind ?? this.declareOptions.assertQueues;
-        try {
-            if (shouldBind) {
-                const result = await this.channel?.bindQueue(queueName, exchangeName, routingKey);
-                this.logger.info(`Queue [${queueName}] has been bound with exchange [${exchangeName}] by routing key [${routingKey}]`);
-                return result;
-            }
-        }
-        catch (err) {
-            this.logger.error(`Error while binding queue [${queueName}] to exchange [${exchangeName}] by routing key [${routingKey}]`, {
-                err,
-            });
-            throw err;
-        }
-    }
-    async bindExchangeToExchanges(exchangeName, bindTo) {
-        for await (const bindOption of bindTo) {
-            await this.bindExchangeToExchange(exchangeName, bindOption);
-        }
-    }
-    async bindExchangeToExchange(exchangeName, bindOptions) {
-        const { bind, exchangeName: relatedExchangeName, routingKey = constants_1.default.DEFAULT_ROUTING_KEY } = bindOptions;
-        const shouldBind = bind ?? this.declareOptions.assertExchanges;
-        try {
-            if (shouldBind) {
-                const result = await this.channel?.bindExchange(exchangeName, relatedExchangeName, routingKey);
-                this.logger.info(`Exchange [${exchangeName}] has been bound with exchange [${relatedExchangeName}] by routing key [${routingKey}]`);
-                return result;
-            }
-        }
-        catch (err) {
-            this.logger.error(`Error while binding exchange [${exchangeName}] to exchange [${relatedExchangeName}] by routing key [${routingKey}]`, {
-                err,
-            });
-            throw err;
-        }
-    }
-    async unbindQueueFromExchange(queueName, unbindOptions) {
-        const { unbind, exchangeName, routingKey = constants_1.default.DEFAULT_ROUTING_KEY } = unbindOptions;
-        try {
-            if (unbind) {
-                const result = await this.channel?.unbindQueue(queueName, exchangeName, routingKey);
-                this.logger.info(`Queue [${queueName}] has been unbound from exchange [${exchangeName}] by routing key [${routingKey}]`);
-                return result;
-            }
-        }
-        catch (err) {
-            this.logger.error(`Error while unbinding queue [${queueName}] from exchange [${exchangeName}] by routing key [${routingKey}]`, {
-                err,
-            });
-            throw err;
-        }
-    }
-    async disconnect() {
-        await this.channel?.close();
-        this.connection.removeAllListeners(interfaces_1.AmqpConnectionEventNames.Ready);
-        await this.connection.closeConnection();
-    }
-    async initChannel() {
-        this.channel = await this.connection.createChannel(this.channelName);
-    }
-    async readConfig(declarationConfigPath) {
-        // eslint-disable-next-line security/detect-non-literal-fs-filename
-        const data = await (0, promises_1.readFile)(declarationConfigPath, { encoding: 'utf8' }); // nosemgrep: eslint.detect-non-literal-fs-filename
-        return JSON.parse(data);
-    }
-    async assertTemporaryQueue(queueOptions) {
-        const tempQueueOptions = this.prepareTemporaryQueueOptions(queueOptions);
-        await this.assertQueue(tempQueueOptions);
-        return tempQueueOptions;
-    }
-    async assertAlternateExchanges(queueOptions, exchangesOptions) {
-        const alternateExchangesOptions = this.prepareAlternateExchangesOptions(queueOptions, exchangesOptions);
-        await this.assertExchanges(Object.values(alternateExchangesOptions));
-        return alternateExchangesOptions;
-    }
-    async assertAlternateQueue(queueOptions, alternateExchangesOptions) {
-        const alternateQueueOptions = this.prepareAlternateQueueOptions(queueOptions, alternateExchangesOptions);
-        await this.assertQueue(alternateQueueOptions);
-        return alternateQueueOptions;
-    }
-    prepareRedeclareQueueOptions(queueOptions, redeclareQueueOptions) {
-        return {
-            ...queueOptions,
-            ...redeclareQueueOptions,
-        };
-    }
-    prepareTemporaryQueueOptions(queueOptions) {
-        return {
-            ...queueOptions,
-            name: `${queueOptions.name}Temporary`,
-        };
-    }
-    prepareAlternateExchangesOptions(queueOptions, exchangesOptions) {
-        const result = {};
-        if (exchangesOptions.length === 0) {
-            return result;
-        }
-        const exchangesOptionsMap = new Map(exchangesOptions.map((exchangeOptions) => [exchangeOptions.name, exchangeOptions]));
-        for (const bindOptions of queueOptions.bindTo) {
-            const { exchangeName, bind } = bindOptions;
-            if (!bind) {
-                continue;
-            }
-            const exchangeOptions = exchangesOptionsMap.get(exchangeName);
-            if (!exchangeOptions) {
-                throw new Error(`Alternate exchange options could not be defined for unknown exchange [${exchangeName}]`);
-            }
-            result[exchangeName] = this.prepareAlternateExchangeOptions(exchangeOptions);
-        }
-        return result;
-    }
-    prepareAlternateExchangeOptions(exchangeOptions) {
-        const { name: exchangeName } = exchangeOptions;
-        return {
-            ...exchangeOptions,
-            declare: true,
-            name: `${exchangeName}${AmqpAsserter.PrefixAlternate}`,
-        };
-    }
-    prepareAlternateQueueOptions(queueOptions, alternateExchangesOptions) {
-        const { name: queueName, bindTo = [] } = queueOptions;
-        return {
-            ...queueOptions,
-            name: `${queueName}${AmqpAsserter.PrefixAlternate}`,
-            bindTo: this.prepareAlternateBindToQueueOption(bindTo, alternateExchangesOptions),
-        };
-    }
-    prepareAlternateBindToQueueOption(bindTo, alternateExchangesOptions) {
-        return bindTo
-            .filter(({ exchangeName }) => exchangeName in alternateExchangesOptions)
-            .map(({ exchangeName, routingKey }) => {
-            const { name: alternateExchangeName } = alternateExchangesOptions[exchangeName];
-            return {
-                bind: true,
-                routingKey,
-                exchangeName: alternateExchangeName,
-            };
-        });
-    }
-}
-exports.AmqpAsserter = AmqpAsserter;
-//# sourceMappingURL=amqpAsserter.js.map
+//#endregion
+export { AmqpAsserter };