@crowdin/app-project-module 0.94.2 → 0.95.0

package/out/modules/context-menu/index.js

@@ -10,8 +10,21 @@ const util_1 = require("../../util");
 function register({ config, app }) {
     var _a, _b;
     const allowUnauthorized = !(0, util_1.isAuthorizedConfig)(config);
-    if (((_a = config.contextMenu) === null || _a === void 0 ? void 0 : _a.uiPath) || ((_b = config.contextMenu) === null || _b === void 0 ? void 0 : _b.formSchema)) {
-        app.use('/context', (0, ui_module_1.default)({ config, allowUnauthorized, moduleType: config.contextMenu.key }), (0, render_ui_module_1.default)(config.contextMenu));
+    if (!config.contextMenu) {
+        return;
+    }
+    if (Array.isArray(config.contextMenu)) {
+        config.contextMenu.forEach((contextMenu) => {
+            if ((contextMenu === null || contextMenu === void 0 ? void 0 : contextMenu.uiPath) || (contextMenu === null || contextMenu === void 0 ? void 0 : contextMenu.formSchema)) {
+                app.use(`/context-${contextMenu.key}`, (0, ui_module_1.default)({ config, allowUnauthorized, moduleType: contextMenu.key }), (0, render_ui_module_1.default)(contextMenu));
+            }
+        });
+    }
+    else {
+        // backward compatibility will be removed after migration
+        if (((_a = config.contextMenu) === null || _a === void 0 ? void 0 : _a.uiPath) || ((_b = config.contextMenu) === null || _b === void 0 ? void 0 : _b.formSchema)) {
+            app.use('/context', (0, ui_module_1.default)({ config, allowUnauthorized, moduleType: config.contextMenu.key }), (0, render_ui_module_1.default)(config.contextMenu));
+        }
     }
 }
 exports.register = register;

package/out/modules/context-menu/types.d.ts

@@ -1,8 +1,9 @@
 import { SignaturePatterns } from '../../types';
-export interface ContextModule {
+export interface ContextContent {
     location: ContextOptionsLocations;
     type: ContextOptionsTypes;
     module: string;
+    moduleKey?: string;
     /**
      * Context menu name
      */

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

@@ -47,6 +47,9 @@ const index_1 = require("../../../util/index");
 const logger_1 = require("../../../util/logger");
 const prefetchCount = 10;
 const forceProcessDelay = 10000;
+const maxReconnectAttempts = 5;
+const baseReconnectDelay = 1000;
+const connectionHeartbeat = 60;
 exports.HookEvents = {
     fileAdded: 'file.added',
     fileDeleted: 'file.deleted',
@@ -341,27 +344,52 @@ function updateCrowdinFromWebhookRequest(args) {
 exports.updateCrowdinFromWebhookRequest = updateCrowdinFromWebhookRequest;
 function listenQueueMessage({ config, integration, queueName, queueUrl, }) {
     return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const connection = yield amqplib_1.default.connect(queueUrl);
-            connection.once('close', function () {
-                setTimeout(() => {
-                    listenQueueMessage({ config, integration, queueUrl, queueName });
-                }, 3000);
+        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();
+            }
+        });
+        const scheduleReconnect = () => __awaiter(this, void 0, void 0, function* () {
+            if (reconnectAttempts >= maxReconnectAttempts) {
+                (0, logger_1.logError)(`Max reconnection attempts (${maxReconnectAttempts}) reached. Stopping reconnection.`);
                 return;
-            });
-            const channel = yield connection.createChannel();
-            if (channel) {
-                yield channel.assertQueue(queueName, { durable: true });
-                yield channel.prefetch(prefetchCount);
-                const onMessage = consumer({ channel, config, integration });
-                yield channel.consume(queueName, onMessage, { noAck: false });
             }
-        }
-        catch (e) {
-            setTimeout(() => {
-                listenQueueMessage({ config, integration, queueUrl, queueName });
-            }, 3000);
-        }
+            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);
+        });
+        yield connect();
     });
 }
 exports.listenQueueMessage = listenQueueMessage;
@@ -370,18 +398,21 @@ function consumer({ channel, config, integration, }) {
     let webhooksInfo = {};
     let webhooksData = [];
     let timeoutId;
+    let messagesToAck = []; // Track messages for individual acknowledgment
     const resetStateVariables = () => {
         messagesCounter = 0;
         webhooksInfo = {};
         webhooksData = [];
+        messagesToAck = [];
     };
     return function (msg) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            messagesCounter++;
             if (!msg) {
                 return;
             }
+            messagesCounter++;
+            messagesToAck.push(msg); // Add message to acknowledgment queue
             clearTimeout(timeoutId);
             try {
                 const data = JSON.parse(msg.content.toString());
@@ -413,7 +444,7 @@ function consumer({ channel, config, integration, }) {
                             webhooksData,
                             webhooksInfo,
                             channel,
-                            msg,
+                            messagesToAck,
                         });
                         resetStateVariables();
                     }), forceProcessDelay);
@@ -424,34 +455,65 @@ function consumer({ channel, config, integration, }) {
                     webhooksData,
                     webhooksInfo,
                     channel,
-                    msg,
+                    messagesToAck,
                 });
                 resetStateVariables();
             }
             catch (e) {
-                (0, logger_1.logError)(e);
+                (0, logger_1.logError)(`Error processing message: ${e}`);
+                // Acknowledge the current message even if there's an error to prevent reprocessing
+                try {
+                    channel.ack(msg);
+                }
+                catch (ackError) {
+                    (0, logger_1.logError)(`Error acknowledging message: ${ackError}`);
+                }
             }
         });
     };
 }
-function processMessages({ channel, msg, webhooksData, webhooksInfo, }) {
+function processMessages({ channel, messagesToAck, webhooksData, webhooksInfo, }) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
+            // Prepare all webhook data first
             yield Promise.all(webhooksData);
+            // Process each client's webhook data individually
             for (const { data, integration, webhookData } of Object.values(webhooksInfo)) {
                 if (webhookData && webhookData.crowdinClient) {
-                    yield updateCrowdinFromWebhookRequest({
-                        integration: integration,
-                        webhookData: webhookData,
-                        req: data,
-                    });
+                    try {
+                        yield updateCrowdinFromWebhookRequest({
+                            integration: integration,
+                            webhookData: webhookData,
+                            req: data,
+                        });
+                    }
+                    catch (processingError) {
+                        (0, logger_1.logError)(`Error processing webhook request: ${processingError}`);
+                        // Continue processing other clients even if one fails
+                    }
+                }
+            }
+            // Acknowledge all messages individually after successful processing
+            for (const msg of messagesToAck) {
+                try {
+                    channel.ack(msg);
+                }
+                catch (ackError) {
+                    (0, logger_1.logError)(`Error acknowledging individual message: ${ackError}`);
                 }
             }
-            channel.ack(msg, true);
         }
         catch (e) {
-            (0, logger_1.logError)(e);
-            channel.nack(msg, false, false);
+            (0, logger_1.logError)(`Error in processMessages: ${e}`);
+            // On critical error, nack all messages to requeue them
+            for (const msg of messagesToAck) {
+                try {
+                    channel.nack(msg, false, true); // requeue the message
+                }
+                catch (nackError) {
+                    (0, logger_1.logError)(`Error nacking message: ${nackError}`);
+                }
+            }
         }
     });
 }

package/out/modules/manifest.js

@@ -210,19 +210,35 @@ function handle(config) {
         modules['modal'] = modals;
     }
     if (config.contextMenu) {
-        // prevent possible overrides of the other modules
-        config.contextMenu = Object.assign(Object.assign({}, config.contextMenu), { key: config.identifier + '-context-menu' });
-        modules['context-menu'] = [
-            Object.assign({ key: config.contextMenu.key, name: config.contextMenu.name || config.name, description: config.description, options: Object.assign(Object.assign({ location: config.contextMenu.location, type: config.contextMenu.type }, (config.contextMenu.module
-                    ? {
-                        module: {
-                            [config.contextMenu.module]: modules[config.contextMenu.module][0].key,
-                        },
-                    }
-                    : {})), { url: '/context/' + (config.contextMenu.fileName || 'index.html') }), signaturePatterns: config.contextMenu.signaturePatterns }, (!!config.contextMenu.environments && {
-                environments: normalizeEnvironments(config.contextMenu.environments),
-            })),
-        ];
+        let contextMenus = [];
+        if (Array.isArray(config.contextMenu)) {
+            contextMenus = config.contextMenu.map((contextMenu, i) => {
+                const moduleKey = contextMenu.key || `${config.identifier}-context-menu-${i}`;
+                return Object.assign({ key: moduleKey, name: contextMenu.name || config.name, description: config.description, options: Object.assign(Object.assign({ location: contextMenu.location, type: contextMenu.type }, (contextMenu.module && contextMenu.moduleKey
+                        ? {
+                            module: {
+                                [contextMenu.module]: contextMenu.moduleKey,
+                            },
+                        }
+                        : {})), { url: `/context-${moduleKey}/` + (contextMenu.fileName || 'index.html') }), signaturePatterns: contextMenu.signaturePatterns }, (!!contextMenu.environments && {
+                    environments: normalizeEnvironments(contextMenu.environments),
+                }));
+            });
+        }
+        else {
+            contextMenus = [
+                Object.assign({ key: config.identifier + '-context-menu', name: config.contextMenu.name || config.name, description: config.description, options: Object.assign(Object.assign({ location: config.contextMenu.location, type: config.contextMenu.type }, (config.contextMenu.module
+                        ? {
+                            module: {
+                                [config.contextMenu.module]: modules[config.contextMenu.module][0].key,
+                            },
+                        }
+                        : {})), { url: '/context/' + (config.contextMenu.fileName || 'index.html') }), signaturePatterns: config.contextMenu.signaturePatterns }, (!!config.contextMenu.environments && {
+                    environments: normalizeEnvironments(config.contextMenu.environments),
+                })),
+            ];
+        }
+        modules['context-menu'] = contextMenus;
     }
     if (config.api) {
         modules['api'] = (0, api_1.getApiManifest)(config, config.api);

package/out/modules/modal/index.js

@@ -21,6 +21,7 @@ function register({ config, app }) {
         });
     }
     else {
+        // backward compatibility will be removed after migration
         if (((_a = config.modal) === null || _a === void 0 ? void 0 : _a.uiPath) || ((_b = config.modal) === null || _b === void 0 ? void 0 : _b.formSchema)) {
             app.use('/modal', (0, ui_module_1.default)({ config, allowUnauthorized, moduleType: config.modal.key }), (0, render_ui_module_1.default)(config.modal));
         }

package/out/types.d.ts

@@ -1,7 +1,7 @@
 import Crowdin from '@crowdin/crowdin-api-client';
 import { JwtPayload, VerifyOptions } from '@crowdin/crowdin-apps-functions';
 import { Request } from 'express';
-import { ContextModule } from './modules/context-menu/types';
+import { ContextContent } from './modules/context-menu/types';
 import { CustomMTLogic } from './modules/custom-mt/types';
 import { CustomSpellcheckerModule } from './modules/custom-spell-check/types';
 import { EditorPanels } from './modules/editor-right-panel/types';
@@ -155,7 +155,7 @@ export interface ClientConfig extends ImagePath {
     /**
      * context menu module
      */
-    contextMenu?: ContextModule & UiModule & Environments;
+    contextMenu?: ContextModule | ContextModule[];
     /**
      * modal module
      */
@@ -499,4 +499,6 @@ export declare enum storageFiles {
 }
 export interface ModalModule extends ModuleContent, UiModule, Environments {
 }
+export interface ContextModule extends ContextContent, UiModule, Environments {
+}
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowdin/app-project-module",
-  "version": "0.94.2",
+  "version": "0.95.0",
   "description": "Module that generates for you all common endpoints for serving standalone Crowdin App",
   "main": "out/index.js",
   "types": "out/index.d.ts",