delore-crm-core 1.0.12 → 1.0.14

package/db/sequelize_db.js

@@ -1,93 +1,158 @@
-const Sequelize = require('sequelize');
-const logger = require('../utils/logger.js');
-const authControl = require('../auth/auth.control.js');
+const Sequelize = require("sequelize");
+const logger = require("../utils/logger.js");
+const authControl = require("../auth/auth.control.js");
 let sequelize = null;
 
-const { MongoClient } = require('mongodb');
+const { MongoClient } = require("mongodb");
 
 const uri = process.env.MONGODB_URI;
 const client = new MongoClient(uri);
 var db = null;
 
+function envInt(name, defaultValue) {
+  const value = Number.parseInt(process.env[name], 10);
+  return Number.isNaN(value) ? defaultValue : value;
+}
+
 async function connectMongoDB() {
-   try {
-      await client.connect();
-      db = client.db('sessions');
-      logger.info('mongoDB - - > Conectado ao MongoDB!');
-      if (db) {
-         await authControl.loadAllSecretToMemory(db);
-      }
-   } catch (error) {
-      logger.error('mongoDB - - > Erro ao conectar:', error.message);
-   }
+  try {
+    await client.connect();
+    db = client.db("sessions");
+    logger.info("mongoDB - - > Conectado ao MongoDB!");
+    if (db) {
+      await authControl.loadAllSecretToMemory(db);
+    }
+  } catch (error) {
+    logger.error("mongoDB - - > Erro ao conectar:", error.message);
+  }
 }
 
 module.exports = {
-   getMongoDB: function () {
-      return db;
-   },
-   getSequelize: function () {
-      return sequelize;
-   },
-   init(onConnect) {
-      sequelize = new Sequelize(process.env.DB_DATABASE, process.env.DB_USER, process.env.DB_PASS, {
-         dialect: 'mysql',
-         host: process.env.DB_HOST,
-         pool: {
-            max: 400, // Aumentar o limite máximo de conexões se o tráfego for alto
-            min: 20, // Manter um número mínimo de conexões ativas
-            idle: 10000, // Tempo que uma conexão pode ficar ociosa (30 segundos)
-            acquire: 60000, // Tempo máximo para aguardar uma conexão do pool (60 segundos)
-            evict: 30000, // Remover conexões ociosas após 30 segundos
-         },
-         timezone: '-03:00',
-         dialectOptions: {
-            multipleStatements: true,
-         },
-         define: {
-            underscored: false,
-            freezeTableName: true,
-            charset: 'utf8',
-            timestamps: false,
-            createdAt: false,
-            updatedAt: false,
-            hooks: {
-               beforeValidate: async (model, options) => {
-                  var models = sequelize.models;
-                  var modelOriginal = models[model.constructor.name];
-                  for (const key in options.fields) {
-                     const field = options.fields[key];
-                     if (modelOriginal && modelOriginal.fieldRawAttributesMap[field] && modelOriginal.fieldRawAttributesMap[field].type.constructor.key == 'DATEONLY') {
-                        if (model[field] === '') {
-                           model[field] = null;
-                        }
-                     }
-                     if (modelOriginal && modelOriginal.fieldRawAttributesMap[field] && modelOriginal.fieldRawAttributesMap[field].type.constructor.key == 'DATE') {
-                        if (model[field] === '') {
-                           model[field] = null;
-                        }
-                     }
+  getMongoDB: function () {
+    return db;
+  },
+  getSequelize: function () {
+    return sequelize;
+  },
+  init(onConnect) {
+    let isolationLevel =
+      process.env.DB_ISOLATION === "REPEATABLE_READ"
+        ? Sequelize.Transaction.ISOLATION_LEVELS.REPEATABLE_READ
+        : Sequelize.Transaction.ISOLATION_LEVELS.READ_COMMITTED;
+    const lockWaitTimeout = envInt("DB_LOCK_WAIT_TIMEOUT", 15);
+
+    logger.info("init - - > Iniciando conexão com o MySQL..." + isolationLevel);
+
+    sequelize = new Sequelize(
+      process.env.DB_DATABASE,
+      process.env.DB_USER,
+      process.env.DB_PASS,
+      {
+        dialect: "mysql",
+        host: process.env.DB_HOST,
+        pool: {
+          max: envInt("DB_POOL_MAX", 30),
+          min: envInt("DB_POOL_MIN", 0),
+          idle: envInt("DB_POOL_IDLE", 10000),
+          acquire: envInt("DB_POOL_ACQUIRE", 30000),
+          evict: envInt("DB_POOL_EVICT", 10000),
+        },
+        timezone: "-03:00",
+        dialectOptions: {
+          multipleStatements: true,
+        },
+        retry: {
+          max: envInt("DB_RETRY_MAX", 3),
+          match: [
+            /Deadlock/i,
+            /ER_LOCK_DEADLOCK/,
+            /ER_LOCK_WAIT_TIMEOUT/,
+            /Lock wait timeout exceeded/i,
+          ],
+          backoffBase: envInt("DB_RETRY_BACKOFF_BASE", 100),
+          backoffExponent: 1.5,
+        },
+        hooks: {
+          afterConnect: async (connection) => {
+            const query = (sql) =>
+              new Promise((resolve, reject) => {
+                connection.query(sql, (error) => {
+                  if (error) reject(error);
+                  else resolve();
+                });
+              });
+
+            await query(
+              `SET SESSION TRANSACTION ISOLATION LEVEL ${isolationLevel.replace(
+                "_",
+                " ",
+              )}`,
+            );
+            await query(
+              `SET SESSION innodb_lock_wait_timeout = ${lockWaitTimeout}`,
+            );
+          },
+        },
+        define: {
+          underscored: false,
+          freezeTableName: true,
+          charset: "utf8",
+          timestamps: false,
+          createdAt: false,
+          updatedAt: false,
+          hooks: {
+            beforeValidate: async (model, options) => {
+              var models = sequelize.models;
+              var modelOriginal = models[model.constructor.name];
+              for (const key in options.fields) {
+                const field = options.fields[key];
+                if (
+                  modelOriginal &&
+                  modelOriginal.fieldRawAttributesMap[field] &&
+                  modelOriginal.fieldRawAttributesMap[field].type.constructor
+                    .key == "DATEONLY"
+                ) {
+                  if (model[field] === "") {
+                    model[field] = null;
+                  }
+                }
+                if (
+                  modelOriginal &&
+                  modelOriginal.fieldRawAttributesMap[field] &&
+                  modelOriginal.fieldRawAttributesMap[field].type.constructor
+                    .key == "DATE"
+                ) {
+                  if (model[field] === "") {
+                    model[field] = null;
                   }
-               },
+                }
+              }
             },
-         },
-         isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.REPEATABLE_READ,
-         logging: (sql) => logger.info(sql),
-      });
+          },
+        },
+        isolationLevel: isolationLevel,
+        logging: (sql) => logger.trace(sql),
+      },
+    );
 
-      sequelize
-         .authenticate()
-         .then(async () => {
-            //
-            // Após conectar ao MySQL, conecta ao MongoDB
-            //
-            await connectMongoDB();
+    sequelize
+      .authenticate()
+      .then(async () => {
+        //
+        // Após conectar ao MySQL, conecta ao MongoDB
+        //
+        await connectMongoDB();
 
-            logger.info('MySQL and MongoDB - - > Connection has been established successfully.');
-            onConnect();
-         })
-         .catch((err) => {
-            logger.error('MySQL and MongoDB - - > Unable to connect to the database:' + err.message);
-         });
-   },
+        logger.info(
+          "MySQL and MongoDB - - > Connection has been established successfully.",
+        );
+        onConnect();
+      })
+      .catch((err) => {
+        logger.error(
+          "MySQL and MongoDB - - > Unable to connect to the database:" +
+            err.message,
+        );
+      });
+  },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "delore-crm-core",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "Core CRM utilities for Delore projects",
   "main": "index.js",
   "type": "commonjs",

package/utils/logger.js

@@ -1,63 +1,74 @@
-const pretty = require('pino-pretty');
+const pretty = require("pino-pretty");
 
 const stream = pretty({
-   levelFirst: true,
-   colorize: true,
-   ignore: 'pid,hostname',
-   translateTime: 'yyyy-mm-dd HH:MM:ss.l',
+  levelFirst: true,
+  colorize: true,
+  ignore: "pid,hostname",
+  translateTime: "yyyy-mm-dd HH:MM:ss.l",
 });
 
-const pino = require('pino')(stream);
+const pino = require("pino")(stream);
 
-pino.level = process.env.PINO_LOG_LEVEL || 'fatal';
+pino.level = process.env.PINO_LOG_LEVEL || "info";
 
 exports = module.exports = {
-
-   setLevel(level) {
-      pino.level = level || 'fatal';
-   },
-
-   getPino() {
-      return pino;
-   },
-
-   info(message) {
-      pino.info(message);
-   },
-
-   info(mensagem, fileName, methodName) {
-      pino.info({ fileName, methodName }, mensagem);
-   },
-
-   debug(message) {
-      pino.debug(message);
-   },
-
-   debug(mensagem, fileName, methodName) {
-      pino.debug({ fileName, methodName }, mensagem);
-   },
-
-   warn(message) {
-      pino.warn(message);
-   },
-
-   warn(mensagem, fileName, methodName) {
-      pino.warn({ fileName, methodName }, mensagem);
-   },
-
-   error(message) {
-      pino.error(message);
-   },
-
-   error(error, fileName, methodName) {
-      pino.error({ error: error.stack || error.message || error, fileName, methodName });
-   },
-
-   fatal(message) {
-      pino.fatal(message);
-   },
-
-   fatal(mensagem, fileName, methodName) {
-      pino.fatal({ fileName, methodName }, mensagem);
-   },
+  setLevel(level) {
+    pino.level = level || "info";
+  },
+
+  getPino() {
+    return pino;
+  },
+
+  info(message) {
+    pino.info(message);
+  },
+
+  info(mensagem, fileName, methodName) {
+    pino.info({ fileName, methodName }, mensagem);
+  },
+
+  debug(message) {
+    pino.debug(message);
+  },
+
+  debug(mensagem, fileName, methodName) {
+    pino.debug({ fileName, methodName }, mensagem);
+  },
+
+  warn(message) {
+    pino.warn(message);
+  },
+
+  warn(mensagem, fileName, methodName) {
+    pino.warn({ fileName, methodName }, mensagem);
+  },
+
+  error(message) {
+    pino.error(message);
+  },
+
+  error(error, fileName, methodName) {
+    pino.error({
+      error: error.stack || error.message || error,
+      fileName,
+      methodName,
+    });
+  },
+
+  fatal(message) {
+    pino.fatal(message);
+  },
+
+  fatal(mensagem, fileName, methodName) {
+    pino.fatal({ fileName, methodName }, mensagem);
+  },
+
+  trace(message) {
+    pino.trace(message);
+  },
+
+  trace(mensagem, fileName, methodName) {
+    pino.trace({ fileName, methodName }, mensagem);
+  },
 };