@nomikos/module-comm 1.0.4 → 1.0.12

package/README.md

@@ -1,53 +1,2 @@
 
-# @nomikos/module-google
-
-Servicios de FCM y GCE
-
-# Sobre redundancia con varios workers pero haciendo de a una tarea
-
-One approach to handling failover in a case where you want redundant consumers but need to process messages in a specific order is to use the exclusive consumer option when setting up the bind to the queue, and to have two consumers who keep trying to bind even when they can't get the exclusive lock.
-
-The process is something like this:
-
-Consumer A starts first and binds to the queue as an exclusive consumer. Consumer A begins processing messages from the queue.
-Consumer B starts next and attempts to bind to the queue as an exclusive consumer, but is rejected because the queue already has an exclusive consumer.
-On a recurring basis, consumer B attempts to get an exclusive bind on the queue but is rejected.
-Process hosting consumer A crashes.
-Consumer B attempts to bind to the queue as an exclusive consumer, and succeeds this time. Consumer B starts processing messages from the queue.
-Consumer A is brought back online, and attempts an exclusive bind, but is rejected now.
-Consumer B continues to process messages in FIFO order.
-While this approach doesn't provide load sharing, it does provide redundancy.
-
-### Exclusive Queues
-An exclusive queue can only be used (consumed from, purged, deleted, etc) by its declaring connection. An attempt to use an exclusive queue from a different connection will result in a channel-level exception RESOURCE_LOCKED with an error message that says cannot obtain exclusive access to locked queue.
-
-Exclusive queues are deleted when their declaring connection is closed or gone (e.g. due to underlying TCP connection loss). They therefore are only suitable for client-specific transient state.
-
-It is common to make exclusive queues server-named.
-
-### Single Active Consumer
-Single active consumer allows to have only one consumer at a time consuming from a queue and to fail over to another registered consumer in case the active one is cancelled or dies. Consuming with only one consumer is useful when messages must be consumed and processed in the same order they arrive in the queue.
-
-A typical sequence of events would be the following:
-
-A queue is declared and some consumers register to it at roughly the same time.
-The very first registered consumer become the single active consumer: messages are dispatched to it and the other consumers are ignored.
-The single active consumer is cancelled for some reason or simply dies. One of the registered consumer becomes the new single active consumer and messages are now dispatched to it. In other terms, the queue fails over automatically to another consumer.
-Note that without the single active consumer feature enabled, messages would be dispatched to all consumers using round-robin.
-
-Single active consumer can be enabled when declaring a queue, with the x-single-active-consumer argument set to true, e.g. with the Java client:
-
-Channel ch = ...;
-Map<String, Object> arguments = new HashMap<String, Object>();
-arguments.put("x-single-active-consumer", true);
-ch.queueDeclare("my-queue", false, false, false, arguments);
-Compared to AMQP exclusive consumer, single active consumer puts less pressure on the application side to maintain consumption continuity. Consumers just need to be registered and failover is handled automatically, there's no need to detect the active consumer failure and to register a new consumer.
-
-The management UI and the CLI can report which consumer is the current active one on a queue where the feature is enabled.
-
-Please note the following about single active consumer:
-
-There's no guarantee on the selected active consumer, it is picked up randomly, even if consumer priorities are in use.
-Trying to register a consumer with the exclusive consume flag set to true will result in an error if single active consumer is enabled on the queue.
-Messages are always delivered to the active consumer, even if it is too busy at some point. This can happen when using manual acknowledgment and basic.qos, the consumer may be busy dealing with the maximum number of unacknowledged messages it requested with basic.qos. In this case, the other consumers are ignored and messages are enqueued.
-It is not possible to enable single active consumer with a policy. Here is the reason why. Policies in RabbitMQ are dynamic by nature, they can come and go, enabling and disabling the features they declare. Imagine suddenly disabling single active consumer on a queue: the broker would start sending messages to inactive consumers and messages would be processed in parallel, exactly the opposite of what single active consumer is trying to achieve. As the semantics of single active consumer do not play well with the dynamic nature of policies, this feature can be enabled only when declaring a queue, with queue arguments.
+# @nomikos/module-comm

package/index.js

@@ -1,11 +1,13 @@
 const AmqpReceiver = require('./src/services/AmqpReceiver')
 const AmqpSender = require('./src/services/AmqpSender')
 const AmqpEncolador = require('./src/services/AmqpEncolador')
+const Emailer = require('./src/services/Emailer')
 const amqpConn = require('./src/lib/amqpServer')
 
 module.exports = {
   AmqpReceiver,
   AmqpSender,
   AmqpEncolador,
+  Emailer,
   amqpConn
 }

package/jest.config.js

@@ -5,21 +5,11 @@ module.exports = {
   // diabolico pq evita mostrar algunos logs cuando los analizo (en dev)
   forceExit: false,
   testEnvironment: 'node',
-  testMatch: [
-    '**/__tests__/**/*.test.js'
-  ],
-  collectCoverageFrom: [
-    'src/**/*.js'
-  ],
-  coveragePathIgnorePatterns: [
-    '/node_modules/',
-    '__tests__',
-    'src/bin'
-  ],
-  testPathIgnorePatterns: [
-    '/node_modules/'
-  ],
+  testMatch: ['**/__tests__/**/*.test.js'],
+  collectCoverageFrom: ['src/**/*.js'],
+  coveragePathIgnorePatterns: ['/node_modules/', '__tests__', 'src/bin'],
+  testPathIgnorePatterns: ['/node_modules/'],
   transform: {
-    '^.+\\.[t|j]sx?$': ['babel-jest', {rootMode: 'upward'}]
+    '^.+\\.[t|j]sx?$': ['babel-jest', { rootMode: 'upward' }]
   }
 }

package/package.json

@@ -1,19 +1,31 @@
 {
   "name": "@nomikos/module-comm",
-  "version": "1.0.4",
-  "description": "Servicios externos de redis, amqp",
+  "version": "1.0.12",
+  "description": "Servicios externos de email, amqp",
+  "author": {
+    "name": "Igor Parra Bastias",
+    "email": "usuario3@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NomikOS/module-comm"
+  },
+  "publishConfig": {
+    "registry": "https://npm.pkg.github.com/NomikOS"
+  },
+  "license": "UNLICENSED",
   "main": "index.js",
-  "prettier": "@nomikos/prettierrc",
   "scripts": {
     "test": "NODE_ENV=test jest",
     "lint": "eslint --fix src && prettier --write \"src/**/*.js\""
   },
-  "author": "Igor Parra B.",
-  "license": "ISC",
   "dependencies": {
     "amqp-connection-manager": "^3.1.1",
     "amqplib": "^0.5.5",
+    "async": "^3.2.0",
     "awilix": "^4.2.6",
+    "nodemailer": "^6.6.3",
+    "nodemailer-smtp-transport": "^2.7.4",
     "yenv": "^2.1.1"
   }
 }

package/src/lib/amqpServer.js

@@ -2,6 +2,7 @@ const { env } = require('./env')
 const amqp = require('amqp-connection-manager')
 const amqpHost = env['amqp-host']
 
+// No se puede exportar en commonJs (es null)
 let amqpConn = null
 
 function amqpClientConnect(loggerRoot) {
@@ -31,6 +32,15 @@ function amqpClientConnect(loggerRoot) {
       resolve(amqpConn)
     })
 
+    amqpConn.on('error', (err) => {
+        console.log('********* Error en la conexión:', err.message)
+        console.error('********* Error en la conexión:', err.message)
+    })
+
+    amqpConn.on('close', () => {
+        console.log('********* La conexión se ha cerrado.')
+    })
+
     // Emitted whenever we disconnect from a broker.
     amqpConn.on('disconnect', function (params) {
       const error = params.err

package/src/lib/retry.js

@@ -0,0 +1,39 @@
+const retryable = require('async/retryable')
+
+const retry = (
+  procedure,
+  params,
+  opts = {
+    times: 5,
+    interval: 100
+  }
+) => {
+  return new Promise((resolve, reject) => {
+    let i = 0
+
+    const apiMethod = async (callback) => {
+      if (i > 0) {
+        console.warn(`Intento ${++i} de ${procedure.name}`, { params, opts })
+      }
+      try {
+        const result = await procedure(params)
+        callback(null, result)
+      } catch (e) {
+        callback(e)
+      }
+    }
+
+    const londonCalling = retryable(opts, (callback) => apiMethod(callback))
+
+    londonCalling((e, result) => {
+      if (e) {
+        return reject(e)
+      }
+      resolve(result)
+    })
+  })
+}
+
+module.exports = {
+  retry: retry
+}

package/src/services/AmqpReceiver.js

@@ -1,65 +1,68 @@
-const amqpClientConnect = require('../lib/amqpServer')
-let channelWrapper = null
+const amqpClientConnect = require("../lib/amqpServer");
+let channelWrapper = null;
 
 module.exports = {
   async init(colas, amqpReceiverAdapter, loggerRoot = null) {
-    const amqpConn = await amqpClientConnect(loggerRoot)
+    const amqpConn = await amqpClientConnect(loggerRoot);
 
     if (!loggerRoot) {
-      loggerRoot = console
+      loggerRoot = console;
       // console.warn escribe a pm2 logs
-      loggerRoot.debug = console.warn
-      loggerRoot.fatal = console.warn
+      loggerRoot.debug = console.warn;
+      loggerRoot.fatal = console.warn;
     }
 
-    await new Promise((resolve) => {
-      if (channelWrapper) {
-        loggerRoot.debug('FATAL: Solo usar un channel para recibir')
-        return
-      }
+    if (channelWrapper) {
+      loggerRoot.debug("FATAL: Solo usar un channel para recibir");
+      return; // Asegúrate de no proceder si el canal ya está establecido
+    }
 
-      channelWrapper = amqpConn.createChannel({
-        name: 'channel-receiver',
-        setup: async (ch) => {
-          loggerRoot.debug('CREANDO CHANNEL PARA CONSUMIR')
+    channelWrapper = amqpConn.createChannel({
+      name: "channel-receiver",
+      setup: async (ch) => {
+        loggerRoot.debug("CREANDO CHANNEL PARA CONSUMIR");
 
-          await Promise.all(
+        try {
+          // Corregido para manejar y devolver promesas correctamente
+          return Promise.all(
             Object.keys(colas).map(async (queueName) => {
-              // Configurar cola
-              const cola = colas[queueName]
-              const options = cola.options
-              const prefetch = cola.prefetch || 1
+              const cola = colas[queueName];
+              const options = cola.options;
+              const prefetch = cola.prefetch || 1;
+
+              // Uso correcto de promesas sin envolver en una nueva promesa innecesariamente
+              await ch.assertQueue(queueName, options);
+              if (
+                options.arguments &&
+                options.arguments["x-dead-letter-routing-key"] &&
+                options.arguments["x-dead-letter-exchange"]
+              ) {
+                const rk = options.arguments["x-dead-letter-routing-key"];
+                const exc = options.arguments["x-dead-letter-exchange"];
+
+                loggerRoot.debug(`Creando dead exchange: ${exc}.dl`);
+                await ch.assertExchange(exc, "direct", { durable: true });
+
+                loggerRoot.debug(`Creando dead letter: ${queueName}.dl`);
+                await ch.assertQueue(`${queueName}.dl`, { durable: true });
+
+                loggerRoot.debug(`Binding dead letter: ${queueName}.dl`);
+                await ch.bindQueue(`${queueName}.dl`, exc, rk);
+              }
 
-              await new Promise((resolve) => {
-                ch.assertQueue(queueName, options)
-                  .then(() => {
-                    if (
-                      options.arguments &&
-                      options.arguments['x-dead-letter-routing-key']
-                    ) {
-                      // Crear su respectivo dead-letter
-                      loggerRoot.debug(`Creando dead letter: ${queueName}.dl`)
-                      ch.assertQueue(`${queueName}.dl`, { durable: true })
-                    }
-                  })
-                  .then(() => {
-                    ch.prefetch(prefetch)
-                    amqpReceiverAdapter(ch, queueName, cola)
-                  })
-                  .then(() => {
-                    loggerRoot.debug(`COLA CONSUMO ${queueName}`)
-                    resolve()
-                  })
-              })
+              ch.prefetch(prefetch);
+              amqpReceiverAdapter(ch, queueName, cola);
+              loggerRoot.debug(`COLA CONSUMO ${queueName}`);
             })
-          ) // end Promise.all
+          ); // end Promise.all
+        } catch (error) {
+          loggerRoot.error(`Error al configurar las colas: ${error.message}`);
         }
-      })
+      },
+    });
 
-      channelWrapper.waitForConnect().then(function () {
-        loggerRoot.debug('CHANEL PARA CONSUMIR LISTO')
-        resolve()
-      })
-    })
-  }
-}
+    // Espera a que el canal esté conectado antes de resolver
+    await channelWrapper.waitForConnect();
+    loggerRoot.debug("CHANNEL PARA CONSUMIR LISTO");
+  },
+};

package/src/services/Emailer.js

@@ -0,0 +1,39 @@
+const { retry } = require('../lib/retry')
+const { env } = require('../lib/env')
+const mailer = require('nodemailer')
+const smtp = require('nodemailer-smtp-transport')
+
+let transportEmail
+
+async function emailer(messageObj) {
+  if (!transportEmail) {
+    const user = env.emailer.user
+    const pass = env.emailer.pass
+    transportEmail = mailer.createTransport(
+      smtp({
+        host: 'in-v3.mailjet.com',
+        port: 25,
+        auth: { user, pass }
+      })
+    )
+  }
+  await transportEmail.sendMail(messageObj)
+}
+
+module.exports = {
+  send: (logger, messageObj) => {
+    return new Promise((resolve, reject) => {
+      retry(emailer, messageObj, {
+        times: 5,
+        interval: (retryCount) => {
+          const inter = 50 * Math.pow(2, retryCount)
+          const m = `Reintento count: ${retryCount}, int:${inter}`
+          logger.info(m)
+          return inter
+        }
+      })
+        .then((response) => resolve(response))
+        .catch((error) => reject(error))
+    })
+  }
+}