@crowdin/app-project-module 1.16.0 → 2.1.0

package/out/modules/integration/util/webhooks.js

@@ -369,52 +369,71 @@ function updateCrowdinFromWebhookRequest(args) {
 }
 function listenQueueMessage(_a) {
     return __awaiter(this, arguments, void 0, function* ({ config, integration, queueName, queueUrl, }) {
-        let reconnectAttempts = 0;
-        const connect = () => __awaiter(this, void 0, void 0, function* () {
-            try {
-                const connection = yield amqplib_1.default.connect(queueUrl, {
-                    heartbeat: connectionHeartbeat, // 60 seconds heartbeat
-                });
-                // Reset reconnect attempts on successful connection
-                reconnectAttempts = 0;
-                connection.on('error', (err) => {
-                    (0, logger_1.logError)(`AMQP connection error: ${err.message}`);
-                });
-                connection.on('close', () => __awaiter(this, void 0, void 0, function* () {
-                    (0, logger_1.logError)('AMQP connection closed, attempting to reconnect...');
-                    yield scheduleReconnect();
-                }));
-                const channel = yield connection.createChannel();
-                if (channel) {
-                    yield channel.assertQueue(queueName, { durable: true });
-                    yield channel.prefetch(prefetchCount);
-                    channel.on('error', (err) => {
-                        (0, logger_1.logError)(`AMQP channel error: ${err.message}`);
-                    });
-                    channel.on('close', () => {
-                        (0, logger_1.logError)('AMQP channel closed');
-                    });
-                    const onMessage = consumer({ channel, config, integration });
-                    yield channel.consume(queueName, onMessage, { noAck: false });
-                }
-            }
-            catch (e) {
-                (0, logger_1.logError)(`Failed to connect to AMQP: ${e}`);
-                yield scheduleReconnect();
-            }
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(queueUrl);
+        }
+        catch (err) {
+            (0, logger_1.logError)(`Invalid AMQP queueUrl: ${err}`);
+            return;
+        }
+        const setup = (model) => __awaiter(this, void 0, void 0, function* () {
+            const channel = yield model.createChannel();
+            yield channel.assertQueue(queueName, { durable: true });
+            yield channel.prefetch(prefetchCount);
+            channel.on('error', (err) => {
+                (0, logger_1.logError)(`AMQP channel error: ${err.message}`);
+            });
+            channel.on('close', () => {
+                (0, logger_1.logError)('AMQP channel closed');
+            });
+            channel.on('handler-error', (err, eventName) => {
+                (0, logger_1.logError)(`AMQP channel handler error on event '${eventName}': ${err}`);
+            });
+            const onMessage = consumer({ channel, config, integration });
+            yield channel.consume(queueName, onMessage, { noAck: false });
         });
-        const scheduleReconnect = () => __awaiter(this, void 0, void 0, function* () {
-            if (reconnectAttempts >= maxReconnectAttempts) {
-                (0, logger_1.logError)(`Max reconnection attempts (${maxReconnectAttempts}) reached. Stopping reconnection.`);
-                return;
-            }
-            reconnectAttempts++;
-            const delay = Math.min(baseReconnectDelay * Math.pow(2, reconnectAttempts - 1), 30000); // Exponential backoff up to 30s
-            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                yield connect();
-            }), delay);
+        let connection;
+        try {
+            connection = yield amqplib_1.default.connect({
+                protocol: parsedUrl.protocol.replace(/:$/, ''),
+                hostname: parsedUrl.hostname,
+                port: parsedUrl.port ? Number(parsedUrl.port) : undefined,
+                username: parsedUrl.username || undefined,
+                password: parsedUrl.password || undefined,
+                vhost: parsedUrl.pathname && parsedUrl.pathname !== '/'
+                    ? decodeURIComponent(parsedUrl.pathname.slice(1))
+                    : undefined,
+                heartbeat: connectionHeartbeat,
+            }, {
+                recovery: {
+                    initialDelay: baseReconnectDelay,
+                    maxDelay: 30000,
+                    factor: 2,
+                    maxRetries: maxReconnectAttempts,
+                    setup,
+                },
+            });
+        }
+        catch (err) {
+            (0, logger_1.logError)(`Failed to connect to AMQP: ${err}`);
+            return;
+        }
+        connection.on('connect', () => {
+            (0, logger_1.log)('AMQP connection established');
+        });
+        connection.on('disconnect', (err) => {
+            (0, logger_1.logError)(`AMQP connection closed, attempting to reconnect: ${err === null || err === void 0 ? void 0 : err.message}`);
+        });
+        connection.on('reconnect-scheduled', ({ attempt, delay }) => {
+            (0, logger_1.logError)(`AMQP reconnecting (attempt ${attempt}, delay ${delay}ms)`);
+        });
+        connection.on('reconnect-failed', (err) => {
+            (0, logger_1.logError)(`AMQP max reconnection attempts (${maxReconnectAttempts}) reached: ${err}`);
+        });
+        connection.on('error', (err) => {
+            (0, logger_1.logError)(`AMQP connection error: ${err.message}`);
         });
-        yield connect();
     });
 }
 function consumer({ channel, config, integration, }) {
@@ -463,15 +482,11 @@ function consumer({ channel, config, integration, }) {
                 }
                 if (messagesCounter < prefetchCount) {
                     // if all messages are not received, wait 10 seconds to force process messages
-                    timeoutId = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                        yield processMessages({
-                            webhooksData,
-                            webhooksInfo,
-                            channel,
-                            messagesToAck,
-                        });
-                        resetStateVariables();
-                    }), forceProcessDelay);
+                    timeoutId = setTimeout(() => {
+                        processMessages({ webhooksData, webhooksInfo, channel, messagesToAck })
+                            .then(() => resetStateVariables())
+                            .catch((err) => (0, logger_1.logError)(`Error in deferred message processing: ${err}`));
+                    }, forceProcessDelay);
                     return;
                 }
                 clearTimeout(timeoutId);
@@ -542,7 +557,7 @@ function processMessages(_a) {
             }
         }
         catch (e) {
-            (0, logger_1.log)(`Error in processMessages: ${e}`);
+            (0, logger_1.logError)(`Error in processMessages: ${e}`);
             for (const msg of messagesToAck) {
                 try {
                     if (isRetryableError(e)) {