exodus-framework 2.0.756 → 2.0.758

package/lib/services/rabitmq.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _amqplib = _interopRequireDefault(require("amqplib"));
+var _app = require("../app");
+var _service = _interopRequireDefault(require("../app/service"));
+var _messaging = _interopRequireDefault(require("../routes/messaging"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Serviço de Mensageria
+ *
+ * @class RabbitMQService
+ * @extends {Service}
+ * @implements {IService}
+ */
+class RabbitMQService extends _service.default {
+  connection;
+  channel;
+  connected;
+  mainRouter;
+
+  //# Initialization
+  constructor() {
+    super();
+  }
+  async init() {
+    if (!this.mainRouter) throw new Error('Need router'); //!sem router
+
+    this.mainRouter = {
+      ..._messaging.default,
+      ...this.mainRouter
+    }; // # Register native router
+    await this.connect();
+  }
+  async registerHandles() {
+    for (const topic of Object.keys(this.mainRouter)) {
+      await this.channel.bindQueue(_app.Core.settings.getAppication().appId, _app.Core.settings.getMessaging().exchanges.main, topic);
+    }
+    await this.channel.consume(_app.Core.settings.getAppication().appId, this.consumeFromQueue.bind(this), {
+      noAck: false
+    });
+  }
+  async connect() {
+    if (this.connected && this.channel) return;else this.connected = true;
+    try {
+      this.log(`⌛️ Connecting to Rabbit-MQ Server`);
+      this.connection = await _amqplib.default.connect(`amqp://${_app.Core.settings.getMessaging().user}:${_app.Core.settings.getMessaging().pass}@${_app.Core.settings.getMessaging().host}:5672`);
+      this.log(`✅ Rabbit MQ Connection is ready`);
+      this.channel = await this.connection.createChannel();
+      await this.channel.assertExchange(_app.Core.settings.getMessaging().exchanges.main, 'topic', {
+        durable: true
+      });
+      await this.channel.assertQueue(_app.Core.settings.getAppication().appId, {
+        durable: true
+      });
+      this.log(`🛸 Created RabbitMQ Channel successfully`);
+      this.registerHandles();
+    } catch (error) {
+      throw new _app.ErrorHandler(`Not connected to MQ Server`, error); // ! throw because starting process
+    }
+  }
+
+  //# Common
+  async sendToQueue(topic, data) {
+    try {
+      if (!this.channel) {
+        await this.connect();
+      }
+      this.channel.publish(_app.Core.settings.getMessaging().exchanges.main, topic, Buffer.from(JSON.stringify({
+        ...data,
+        serviceId: _app.Core.settings.getAppication().appId
+      })), {
+        messageId: new Date().toDateString(),
+        persistent: true
+      });
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro no envio de uma mensagem para o rabitmq', error);
+    }
+  }
+  async consumeFromQueue(msg) {
+    if (!msg) {
+      return this.log(`Invalid incoming message in`);
+    }
+    try {
+      const topic = msg.fields.routingKey;
+      const content = JSON.parse(msg.content.toString());
+      const callBack = this.mainRouter[topic];
+      callBack(content.data, () => this.channel.ack(msg), content.serviceId);
+    } catch (error) {
+      this.channel.ack(msg);
+      new _app.ErrorHandler('Error on parsing message from queue', error);
+    }
+  }
+  registerRouter(router) {
+    this.mainRouter = router;
+  }
+}
+var _default = exports.default = RabbitMQService;

package/lib/services/redis.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _redis = require("redis");
+var _app = require("../app");
+var _service = _interopRequireDefault(require("../app/service"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Serviço de cache
+ *
+ * @class RedisService
+ * @extends {Service}
+ * @implements {IService}
+ */
+class RedisService extends _service.default {
+  client;
+
+  //* Initialization
+  async init() {
+    this.client = (0, _redis.createClient)({
+      url: `redis://${_app.Core.settings.getCache().host}:${_app.Core.settings.getCache().port}`,
+      password: _app.Core.settings.getCache().password
+    });
+    await this.connect();
+  }
+  connect() {
+    this.client.on('error', this.onClientError.bind(this));
+    return new Promise((resolve, reject) => {
+      this.client.connect().then(() => {
+        this.log('Redis client connected.', 'success');
+        resolve(true);
+      }).catch(reason => {
+        new _app.ErrorHandler('Error on conecting Redis', reason);
+        reject(reason);
+      });
+    });
+  }
+  async disconnect() {
+    await this.client.quit();
+  }
+
+  //* Common
+  async setValue(key, value) {
+    await this.client.set(key, value);
+  }
+  async getValue(key) {
+    const value = await this.client.get(key);
+    return value;
+  }
+  async deleteValue(key) {
+    await this.client.del(key);
+  }
+
+  //* Events
+  onClientError(err) {
+    new _app.ErrorHandler('Error on init redis client', err);
+  }
+}
+var _default = exports.default = RedisService;

package/lib/services/security.js

@@ -0,0 +1,229 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var crypto = _interopRequireWildcard(require("crypto"));
+var fs = _interopRequireWildcard(require("fs"));
+var _nodeJose = require("node-jose");
+var _path = _interopRequireDefault(require("path"));
+var _app = require("../app");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+class SecurityService extends _app.Service {
+  privateKey;
+  publicKey;
+  servicePublicKey;
+  async init() {
+    this.checkPaths();
+    await this.loadPrivateKey();
+    await this.loadPublicKey();
+    await this.loadServicePublicKey();
+  }
+  checkPaths() {
+    !fs.existsSync(_app.Core.settings.getAuthentication().certPath) && fs.mkdirSync(_app.Core.settings.getAuthentication().certPath, {
+      recursive: true
+    });
+  }
+
+  /* Key Pair */
+  async loadPrivateKey() {
+    const privateKeyPath = _path.default.join(_app.Core.settings.getAuthentication().certPath, 'private_key.pem');
+    if (fs.existsSync(privateKeyPath)) {
+      const pem = fs.readFileSync(privateKeyPath, 'utf8');
+      this.privateKey = await _nodeJose.JWK.asKey(pem, 'pem');
+    } else {
+      const {
+        privateKey
+      } = await this.createKeyPairs();
+      this.privateKey = await _nodeJose.JWK.asKey(privateKey, 'pem');
+      const pem = this.privateKey.toPEM(true);
+      fs.writeFileSync(privateKeyPath, pem, 'utf8');
+    }
+  }
+  async loadPublicKey() {
+    const publicKeyPath = _path.default.join(_app.Core.settings.getAuthentication().certPath, 'public_key.pem');
+    const pem = this.privateKey.toPEM(false);
+    this.publicKey = await _nodeJose.JWK.asKey(pem, 'pem');
+    fs.writeFileSync(publicKeyPath, pem, 'utf8');
+  }
+  async createKeyPairs() {
+    const keyPair = await _nodeJose.JWK.createKey('RSA', 2048, {
+      alg: 'RS256',
+      use: 'sig',
+      iss: _app.Core.settings.getAuthentication().issuer
+    });
+    return {
+      publicKey: keyPair.toPEM(false),
+      privateKey: keyPair.toPEM(true)
+    };
+  }
+  async loadServicePublicKey() {
+    if (fs.existsSync(_app.Core.settings.getAuthentication().servicePublicKeyPath)) {
+      const pem = fs.readFileSync(_app.Core.settings.getAuthentication().servicePublicKeyPath, 'utf8');
+      this.servicePublicKey = await _nodeJose.JWK.asKey(pem, 'pem');
+    } else {
+      throw new Error('Não foi possível localizar o certificado de serviço. Verifique o caminho nas configurações');
+    }
+  }
+  async loadKeyByStr(data) {
+    return await _nodeJose.JWK.asKey(data, 'pem');
+  }
+
+  /**
+   * Chave privada emitida por este serviço
+   *
+   * @memberof SecurityService
+   */
+  getPrivateKey() {
+    return this.privateKey;
+  }
+  /**
+   * Chave publica emitida por este serviço
+   *
+   * @memberof SecurityService
+   */
+  getPublicKey() {
+    return this.publicKey;
+  }
+  /**
+   * Chave publica emitida pelo serviço do hub se sessões
+   *
+   * @memberof SecurityService
+   */
+  getServicePublicKey() {
+    return this.servicePublicKey;
+  }
+  /**
+   * Criptografía utilizando chave publica
+   *
+   * @param {TSignData} data
+   * @memberof SecurityService
+   */
+  async encrypt(data, publicKey) {
+    const currentTime = Math.floor(Date.now() / 1000);
+    const defaults = {
+      iat: currentTime,
+      exp: currentTime + _app.Core.settings.getAuthentication().signExpirationSecs,
+      iss: _app.Core.settings.getAuthentication().issuer
+    };
+    const payload = JSON.stringify({
+      ...defaults,
+      ...data
+    });
+    try {
+      const encrypted = await _nodeJose.JWE.createEncrypt({
+        format: 'compact'
+      }, publicKey).update(payload).final();
+      return encrypted;
+    } catch (error) {
+      new _app.ErrorHandler('Não foi possível criptografar os dados', error);
+      return false;
+    }
+  }
+  /**
+   * Descriptografia utilizando chave privada
+   *
+   * @param {string} encryptedData
+   * @memberof SecurityService
+   */
+  async decrypt(encryptedData, privateKey) {
+    try {
+      const decrypted = await _nodeJose.JWE.createDecrypt(privateKey).decrypt(encryptedData);
+      const result = decrypted.plaintext.toString();
+      const parserd = JSON.parse(result);
+      // Tenta parsear como JSON se for objeto
+      return parserd.payload;
+    } catch (error) {
+      new _app.ErrorHandler('Não foi possível descriptografar os dados', error);
+      return false;
+    }
+  }
+  /**
+   * Realiza uma assinatura usando chave privada
+   *
+   * @param {TSignData} data
+   * @memberof SecurityService
+   */
+  async sign(data, privateKey) {
+    const currentTime = Math.floor(Date.now() / 1000);
+    const defaults = {
+      iat: currentTime,
+      exp: currentTime + _app.Core.settings.getAuthentication().signExpirationSecs,
+      iss: _app.Core.settings.getAuthentication().issuer
+    };
+    try {
+      const payload = JSON.stringify({
+        ...defaults,
+        ...data
+      });
+      const signature = await _nodeJose.JWS.createSign({
+        compact: true,
+        fields: {
+          typ: 'jwt'
+        }
+      }, privateKey).update(payload, 'utf8').final();
+      return signature;
+    } catch (error) {
+      new _app.ErrorHandler('Erro ao assinar os dados', error);
+    }
+  }
+
+  /**
+   * Verifica assinatura utilizando chave publica
+   *
+   * @param {string} signature
+   * @memberof SecurityService
+   */
+  async verifySignature(signature, publicKey) {
+    try {
+      const result = await _nodeJose.JWS.createVerify(publicKey).verify(signature);
+      const payload = result.payload.toString();
+      return JSON.parse(payload);
+    } catch (error) {
+      new _app.ErrorHandler('Assinatura inválida ou erro durante a verificação', error);
+    }
+  }
+
+  /**
+   * Criptografía de dados utilizando um buffer automático ao invés de chaves
+   *
+   * @param {(string | object)} data
+   * @memberof SecurityService
+   */
+  simpleEncrypt(data) {
+    if (process.versions.openssl <= '1.0.1f') {
+      throw new Error('OpenSSL Version too old, vulnerability to Heartbleed');
+    }
+    const key = crypto.randomBytes(32);
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(key), iv);
+    let encrypted = cipher.update(data);
+    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    return [iv.toString('hex') + ':' + encrypted.toString('hex'), key];
+  }
+  /**
+   * Utiliza um buffer para descriptografar dados criptografados através de simpleEncrypt()
+   *
+   * @param {string} data
+   * @param {Buffer} key
+   * @memberof SecurityService
+   */
+  simpleDecrypt(data, key) {
+    try {
+      const textParts = data.split(':');
+      const iv = Buffer.from(textParts.shift(), 'hex');
+      const encryptedText = Buffer.from(textParts.join(':'), 'hex');
+      const decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(key), iv);
+      let decrypted = decipher.update(encryptedText);
+      decrypted = Buffer.concat([decrypted, decipher.final()]);
+      return decrypted;
+    } catch (error) {
+      new _app.ErrorHandler('Erro durante a descriptografia de dados', error);
+      return false;
+    }
+  }
+}
+var _default = exports.default = SecurityService;

package/lib/services/sequelize.js

@@ -0,0 +1,285 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _sequelize = require("sequelize");
+var _app = require("../app");
+var _service = _interopRequireDefault(require("../app/service"));
+var _models = require("../models");
+var _DatabaseHost = require("../models/DatabaseHost");
+var _database = require("../utils/database");
+var _logger = _interopRequireDefault(require("../utils/logger"));
+var _security = _interopRequireDefault(require("./security"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Serviço de gerênciamento do banco de dados
+ *
+ * @class SequelizeService
+ * @extends {Service}
+ * @implements {IService}
+ */
+class SequelizeService extends _service.default {
+  serviceDB;
+  masterDB;
+  models;
+  connections;
+  initializedModels;
+  relations;
+
+  //# Initialization
+  constructor() {
+    super();
+  }
+  async init() {
+    this.serviceDB = _database.serviceDB;
+    this.masterDB = _database.masterDB;
+    this.connections = new Map();
+    this.initializedModels = new Map();
+    this.relations = new Map();
+    await this.connectDatabases();
+  }
+  async connectDatabases() {
+    if (!this.models) throw new Error('Models are requireds! Call registerModels(modelsArray)');
+
+    // #Include native models
+    this.models = [...this.models, ..._models.NativeModels];
+    return new Promise((resolve, reject) => {
+      this.masterDB.sync({
+        force: false
+      }).then(() => {
+        this.log('✅ Connected master database sucessfully', 'success');
+        this.serviceDB.sync({
+          force: false
+        }).then(() => {
+          this.log('✅ Connected service database sucessfully', 'success');
+          resolve(true);
+        }).catch(reason => {
+          new _app.ErrorHandler('Não foi possível inicializar a conexão com o ServiceDB', reason);
+          reject(reason);
+        });
+      }).catch(reason => {
+        new _app.ErrorHandler('Não foi possível inicializar a conexão com MasterDB', reason);
+        reject(reason);
+      });
+    });
+  }
+
+  // #Database
+  async getDB(tenantId) {
+    /* master or service */
+    if (tenantId == _app.Core.settings.getDatabase().service.database) {
+      return _database.serviceDB;
+    } else if (tenantId == _app.Core.settings.getDatabase().master.database) {
+      return _database.masterDB;
+    }
+    const relation = await this.getRelation(tenantId);
+    if (!relation) return false;
+    const key = `${relation.hostUuid}@${this.getDBName(relation.envToken)}`;
+    return this.connections.get(key) || (await this.initDB(tenantId));
+  }
+  async createDB(hostUuid, name) {
+    const host = await _DatabaseHost.DatabaseHost.findByPk(hostUuid);
+    if (!host) {
+      this.log('Database host information not found: ' + hostUuid);
+      return false;
+    }
+    const dbQueryName = `${_app.Core.settings.getDatabase().service.database}_${name}`;
+    const connection = await this.createConnection(hostUuid);
+    if (connection) {
+      try {
+        const [results] = await connection.query(`SHOW DATABASES LIKE '${dbQueryName}';`);
+        if (results.length === 0) {
+          // Se o banco de dados não existir, cria-o
+          await connection.query(`CREATE DATABASE ${dbQueryName};`);
+          this.log(`Database "${dbQueryName}" has been created.`);
+          return true;
+        } else {
+          this.log(`Database "${dbQueryName}" already exists.`);
+          return false;
+        }
+      } catch (error) {
+        new _app.ErrorHandler('Erro on creating database', error);
+      } finally {
+        connection.close();
+      }
+    }
+    return false;
+  }
+  async hasDB(hostUuid, name) {
+    const host = await _DatabaseHost.DatabaseHost.findByPk(hostUuid);
+    if (!host) {
+      this.log('Database host information not found: ' + hostUuid);
+      return false;
+    }
+    const dbQueryName = `${_app.Core.settings.getDatabase().service.database}_${name}`;
+    const connection = await this.createConnection(hostUuid);
+    if (connection) {
+      try {
+        const [results] = await connection.query(`SHOW DATABASES LIKE '${dbQueryName}';`);
+        return results.length > 0;
+      } catch (error) {
+        new _app.ErrorHandler('Erro on creating database', error);
+      } finally {
+        connection.close();
+      }
+    }
+    return false;
+  }
+  async deleteDB(hostUuid, name) {
+    const dbQueryName = `${_app.Core.settings.getDatabase().service.database}_${name}`;
+    const connection = await this.createConnection(hostUuid);
+    if (connection) {
+      try {
+        await connection.query(`DROP DATABASE IF EXISTS ${dbQueryName};`);
+        this.log(`Database "${dbQueryName}" has been deleted.`);
+        return true;
+      } catch (error) {
+        return false;
+      } finally {
+        connection.close();
+      }
+    }
+    return false;
+  }
+  async initDB(tenantId) {
+    const relation = await this.getRelation(tenantId);
+    if (!relation) return false;
+    const dbName = this.getDBName(relation.envToken);
+    const key = `${relation.hostUuid}@${this.getDBName(relation.envToken)}`;
+    if (this.connections.has(key)) return this.connections.get(key);
+    const connection = await this.createConnection(relation.hostUuid, dbName);
+    if (connection) {
+      this.log(`✅ Connected ${dbName} database sucessfully`, 'success');
+      this.connections.set(key, connection);
+      return connection;
+    }
+  }
+  getDBName(envToken) {
+    return `${_app.Core.settings.getDatabase().service.database}_${envToken}`;
+  }
+
+  //#Connection
+  reconnect(db, attempts = 2) {
+    db.sync().then(() => {
+      this.log('Database pronto', 'success');
+    }).catch(reason => {
+      this.log('Attemping to connect master database', 'warning');
+      (0, _logger.default)().warn('Erro ao inicializar o banco de dados, tentando novamente...', reason);
+      if (attempts > 0) {
+        setTimeout(() => this.reconnect(db, attempts - 1), 5000);
+      } else {
+        new _app.ErrorHandler('Error on connecting master database', reason);
+      }
+    });
+  }
+  async createConnection(hostUuid, database) {
+    const host = await _DatabaseHost.DatabaseHost.findByPk(hostUuid);
+    if (!host) {
+      this.log('createConnection:: Database host information not found: ' + hostUuid);
+      return false;
+    }
+    const key = await _security.default.singleton().loadKeyByStr(host.credential);
+    const data = await _security.default.singleton().verifySignature(host.password, key);
+    if (!data) {
+      this.log('createConnection::Error on decript password by credential: ' + hostUuid, 'danger');
+      return false;
+    }
+    const password = data.payload;
+    const queryHost = host.host.split(':');
+    const sequelize = new _sequelize.Sequelize({
+      host: queryHost[0],
+      port: Number(queryHost[1]),
+      dialect: host.dialect,
+      database,
+      username: host.username,
+      password: password,
+      define: {
+        timestamps: true
+      },
+      timezone: '-03:00',
+      logging(sql, timing) {
+        (0, _logger.default)().trace('DATABASE', sql, timing);
+      }
+    });
+    return new Promise((resolve, reject) => {
+      sequelize.authenticate().then(async () => {
+        resolve(sequelize);
+      }).catch(reason => {
+        reject(reason);
+      });
+    });
+  }
+  async testConnection(data) {
+    const sequelize = new _sequelize.Sequelize({
+      host: data.host,
+      port: data.port,
+      username: data.username,
+      password: data.password,
+      dialect: data.dialect,
+      timezone: '-03:00',
+      logging(sql, timing) {
+        (0, _logger.default)().trace('DATABASE', sql, timing);
+      }
+    });
+    return new Promise(resolve => {
+      sequelize.authenticate().then(async () => {
+        resolve(true);
+      }).catch(reason => {
+        new _app.ErrorHandler('teste de conexão falhou', reason);
+        resolve(false);
+      }).finally(() => {
+        sequelize.close();
+      });
+    });
+  }
+
+  //# Common
+  async getRelation(tenantId) {
+    let relation;
+    /* fetch relation */
+    if (this.relations.get(tenantId)) {
+      relation = this.relations.get(tenantId);
+    } else {
+      relation = await _models.EnvDBHost.findOne({
+        where: {
+          envUuid: tenantId
+        }
+      });
+      if (relation) {
+        this.relations.set(tenantId, relation);
+      }
+    }
+    return relation;
+  }
+
+  // #Entity
+  async getModel(model, tenantId) {
+    try {
+      let connection = false;
+      const modelKey = `${tenantId}#${model.name}`;
+      if (tenantId == _app.Core.settings.getDatabase().service.database) {
+        connection = _database.serviceDB;
+      } else if (tenantId == _app.Core.settings.getDatabase().master.database) {
+        connection = _database.masterDB;
+      } else {
+        connection = await this.getDB(tenantId);
+      }
+      if (this.initializedModels.has(modelKey)) return this.initializedModels.get(modelKey);
+      if (!connection) {
+        throw new Error('Conexão não encontrada');
+      }
+      const m = model.initialize(connection);
+      await m.sync();
+      this.initializedModels.set(modelKey, m);
+      return m;
+    } catch (error) {
+      throw new _app.ErrorHandler('Erro ao obter o model', error);
+    }
+  }
+  registerModels(models) {
+    this.models = models;
+  }
+}
+var _default = exports.default = SequelizeService;