exodus-framework 2.0.699 → 2.0.700

package/lib/services/security.js

@@ -0,0 +1,224 @@
+"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");
+var _error = require("./error");
+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();
+  }
+  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');
+    }
+  }
+  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.ApplicationException('Não foi possível localizar o certificado de serviço. Verifique o caminho nas configurações');
+    }
+  }
+
+  /**
+   * 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 _error.ApplicationException('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 _error.ApplicationException('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) {
+      throw new _error.ApplicationException('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 _error.ApplicationException('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 _error.ApplicationException('Erro durante a descriptografia de dados', error);
+      return false;
+    }
+  }
+}
+var _default = exports.default = SecurityService;

package/lib/services/sequelize.js

@@ -0,0 +1,242 @@
+"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 _Connection = require("../models/Connection");
+var _database = require("../utils/database");
+var _logger = _interopRequireDefault(require("../utils/logger"));
+var _error = require("./error");
+var _models = require("../models");
+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;
+
+  //# Initialization
+  constructor() {
+    super();
+  }
+  async init() {
+    this.serviceDB = _database.serviceDB;
+    this.masterDB = _database.masterDB;
+    this.connections = new Map();
+    this.initializedModels = new Map();
+    await this.connectMainDatabase();
+  }
+  async connectMainDatabase() {
+    if (!this.models) throw new _error.ApplicationException('Models are requireds! Call registerModels(modelsArray)');
+
+    // #Include native models
+    this.models = [...this.models, ..._models.NativeModels];
+    return new Promise(resolve => {
+      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 _error.ApplicationException('Não foi possível inicializar a conexão com o ServiceDB', reason);
+        });
+      }).catch(reason => {
+        new _error.ApplicationException('Não foi possível inicializar a conexão com MasterDB', reason);
+      });
+    });
+  }
+
+  //# Common
+  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 _error.ApplicationException('Error on connecting master database', reason);
+      }
+    });
+  }
+  getMasterConnection() {
+    return this.masterDB;
+  }
+  async createDB(connection_uuid, name) {
+    const connData = await _Connection.Connection.findByPk(connection_uuid);
+    if (!connData) {
+      this.log('Connection data not found: ' + connection_uuid);
+      return false;
+    }
+    const dbQueryName = `${_app.Core.settings.getDatabase().service.database}_${name}`;
+    const sequelize = new _sequelize.Sequelize({
+      dialect: connData.dialect,
+      username: connData.username,
+      password: connData.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 () => {
+        const [results] = await sequelize.query(`SHOW DATABASES LIKE '${dbQueryName}';`);
+        if (results.length === 0) {
+          // Se o banco de dados não existir, cria-o
+          await sequelize.query(`CREATE DATABASE ${dbQueryName};`);
+          this.log(`Database "${dbQueryName}" has been created.`);
+          resolve(true);
+        } else {
+          this.log(`Database "${dbQueryName}" already exists.`);
+          resolve(false);
+        }
+      }).catch(reason => {
+        new _error.ApplicationException('Error while checking/creating database:', reason);
+        reject(reason);
+      }).finally(() => {
+        sequelize.close();
+      });
+    });
+  }
+  async deleteDB(connection_uuid, name) {
+    const dbQueryName = `${_app.Core.settings.getDatabase().service.database}_${name}`;
+    const connData = await _Connection.Connection.findByPk(connection_uuid);
+    if (!connData) {
+      this.log('Connection data not found: ' + connection_uuid);
+      return false;
+    }
+    const sequelize = new _sequelize.Sequelize({
+      dialect: connData.dialect,
+      username: connData.username,
+      password: connData.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 () => {
+        // Se o banco de dados não existir, cria-o
+        await sequelize.query(`DROP DATABASE IF EXISTS ${dbQueryName};`);
+        this.log(`Database "${dbQueryName}" has been deleted.`);
+        resolve(true);
+      }).catch(reason => {
+        new _error.ApplicationException('Error while checking/deleting database:', reason);
+        reject(reason);
+      }).finally(() => {
+        sequelize.close();
+      });
+    });
+  }
+  async getDB(tenantId) {
+    const {
+      con_uuid,
+      envToken
+    } = this.parseDataInfoByTenantId(tenantId);
+    if (con_uuid == _app.Core.settings.getDatabase().service.database) {
+      return _database.serviceDB;
+    } else if (con_uuid == _app.Core.settings.getDatabase().master.database) {
+      return _database.masterDB;
+    }
+    const dbName = `${_app.Core.settings.getDatabase().service.database}_${envToken}`; //nomeclatura padrão do banco de dados do serviço
+    const queryId = `${con_uuid}@${dbName}`;
+    return this.connections.get(queryId) || (await this.initDB(tenantId));
+  }
+  async initDB(tenantId) {
+    const {
+      con_uuid,
+      envToken
+    } = this.parseDataInfoByTenantId(tenantId);
+    const dbName = `${_app.Core.settings.getDatabase().service.database}_${envToken}`; //nomeclatura padrão do banco de dados do serviço
+    const queryId = `${con_uuid}@${dbName}`;
+    if (this.connections.get(queryId)) {
+      return this.connections.get(queryId);
+    }
+    const connData = await _Connection.Connection.findByPk(con_uuid);
+    if (!connData) {
+      this.log('Error on init connection, data not found! uuid: ' + con_uuid, 'danger');
+      return false;
+    }
+    const conn = new _sequelize.Sequelize({
+      database: dbName,
+      dialect: connData.dialect,
+      username: connData.username,
+      password: connData.password,
+      define: {
+        timestamps: true
+      },
+      timezone: '-03:00',
+      logging(sql, timing) {
+        (0, _logger.default)().trace('DATABASE', sql, timing);
+      }
+    });
+    return new Promise((resolve, reject) => {
+      conn.sync({
+        force: false
+      }).then(() => {
+        this.log(`✅ Connected ${dbName} database sucessfully`, 'success');
+        this.connections.set(queryId, conn);
+        resolve(conn);
+      }).catch(reason => {
+        this.log(`error trying to connect: ${dbName}, UUID: ${con_uuid}`);
+        reject(reason);
+        new _error.ApplicationException(`error trying to connect: ${dbName}, UUID: ${con_uuid}`, reason);
+      });
+    });
+  }
+  registerModels(models) {
+    this.models = models;
+  }
+  async getModel(model, tenantId) {
+    const {
+      con_uuid,
+      envToken
+    } = this.parseDataInfoByTenantId(tenantId);
+    const modelInitID = `${envToken}@${con_uuid}#${model.name}`;
+    const cache = this.initializedModels.get(modelInitID);
+    if (cache) {
+      return cache;
+    }
+    const connection = await this.getDB(tenantId);
+    if (!connection) {
+      throw new _error.ApplicationException('Não foi possível obter o model espeficificado: Conexão não encontrada');
+    }
+    const m = model.initialize(connection);
+    await m.sync();
+    this.initializedModels.set(modelInitID, m);
+    return m;
+  }
+  parseDataInfoByTenantId(tenant) {
+    const e = tenant.split('@');
+    const envToken = e[0];
+    const con_uuid = e[1];
+    return {
+      envToken,
+      con_uuid
+    };
+  }
+}
+var _default = exports.default = SequelizeService;

package/lib/services/socket.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _controller = require("../app/controller");
+var _service = _interopRequireDefault(require("../app/service"));
+var _socket = require("socket.io");
+var _express = _interopRequireDefault(require("./express"));
+var _error = require("./error");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Serviço de gerênciamento de comunicação WS/WSS Socket
+ *
+ * @class SocketIOService
+ * @extends {Service}
+ * @implements {IService}
+ */
+class SocketIOService extends _service.default {
+  server;
+  mainRouter;
+  constructor() {
+    super();
+  }
+  async init() {
+    if (!this.mainRouter) throw new _error.ApplicationException('Need router'); //!sem router
+    const server = _express.default.singleton().getHttpServer();
+    this.createSocket(server);
+    this.server.on('connection', this.onConnection.bind(this));
+    this.log('Socket server created');
+  }
+  onConnection(socket) {
+    this.log(`${socket.id} conectado`);
+    socket.on('disconnect', () => this.log(`${socket.id} desconectado`));
+    this.bindEvents(socket);
+  }
+  bindEvents(socket) {
+    Object.entries(this.mainRouter).forEach(([key, handle]) => {
+      socket.on(key, (...args) => {
+        handle(new _controller.SocketRequest(socket, key), ...args);
+      });
+    });
+  }
+  createSocket(app, cors = {
+    origin: '*'
+  }) {
+    this.server = new _socket.Server(app, {
+      cors
+    });
+  }
+  registerRouter(router) {
+    this.mainRouter = router;
+  }
+}
+var _default = exports.default = SocketIOService;

package/lib/services/task.js

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TaskSchedulingService = exports.TaskQueueService = exports.SchedulingTask = exports.QueueTask = void 0;
+var _bullmq = require("bullmq");
+var _fs = require("fs");
+var _nodeSchedule = require("node-schedule");
+var _service = _interopRequireDefault(require("../app/service"));
+var _singleton = _interopRequireDefault(require("../app/singleton"));
+var _error = require("./error");
+var _app = require("../app");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//* Base
+class TaskServiceBase extends _service.default {
+  jobsPath;
+  setTaskPath(path) {
+    this.jobsPath = path;
+  }
+}
+
+//* Scheduler
+class TaskSchedulingService extends TaskServiceBase {
+  jobs;
+  async init() {
+    if (!this.jobsPath) {
+      return this.log('Tasks file path not found!', 'danger');
+    }
+    this.jobs = [];
+    this.log('Initializing jobs...', 'info');
+    await this.importAllJobs();
+    await this.processAllJobs();
+    this.log('All jobs initializeds...', 'info');
+  }
+  async registerJob(job) {
+    this.jobs.push(job);
+  }
+  async importAllJobs() {
+    if (!(0, _fs.existsSync)(this.jobsPath)) (0, _fs.mkdirSync)(this.jobsPath, {
+      recursive: true
+    });
+    for (const handlerFile of (0, _fs.readdirSync)(this.jobsPath)) {
+      try {
+        const job = require(`${this.jobsPath}/${handlerFile}`).default;
+        const jobInstance = job.singleton();
+        this.jobs.push(jobInstance);
+      } catch (error) {
+        new _error.ApplicationException(`Falha ao iniciar um ou mais jobs: ${handlerFile}`, error);
+      }
+    }
+  }
+  async processAllJobs() {
+    for (const job of this.jobs) {
+      if (!job.getActive()) continue;
+      (0, _nodeSchedule.scheduleJob)(job.getJobTime(), job.handler.bind(job));
+      this.log(`Job '${job.getJobName()}' started...`, 'warning');
+    }
+  }
+}
+exports.TaskSchedulingService = TaskSchedulingService;
+class SchedulingTask extends _singleton.default {
+  getJobTime() {
+    return this.cron;
+  }
+  getActive() {
+    return this.active;
+  }
+  getJobName() {
+    return this.name;
+  }
+}
+
+//* Queue
+exports.SchedulingTask = SchedulingTask;
+class TaskQueueService extends TaskServiceBase {
+  jobs;
+  connection;
+  async init() {
+    this.jobs = [];
+    this.connection = {
+      host: _app.Core.settings.getCache().host,
+      port: Number(_app.Core.settings.getCache().port),
+      password: _app.Core.settings.getCache().password
+    };
+    this.log('Initializing jobs...', 'info');
+    await this.importAllJobs();
+    await this.processAllJobs();
+    this.log('All jobs initializeds...', 'info');
+  }
+  async registerJob(job) {
+    this.jobs.push(job);
+  }
+  async importAllJobs() {
+    if (!(0, _fs.existsSync)(this.jobsPath)) (0, _fs.mkdirSync)(this.jobsPath, {
+      recursive: true
+    });
+    for (const handlerFile of (0, _fs.readdirSync)(this.jobsPath)) {
+      const job = require(`${this.jobsPath}/${handlerFile}`).default;
+      const jobInstance = job.singleton();
+      this.jobs.push(jobInstance);
+    }
+  }
+  async processAllJobs() {
+    for (const job of this.jobs) {
+      if (!job.getActive()) continue;
+      const queue = new _bullmq.Queue(job.getQueueName(), {
+        connection: this.connection
+      });
+      const worker = new _bullmq.Worker(job.getQueueName(), job.handle.bind(job), {
+        connection: this.connection
+      });
+      job.setQueue(queue);
+      job.setWorker(worker);
+      job.init();
+      this.log(`Job '${job.getQueueName()}' started...`, 'warning');
+    }
+  }
+}
+exports.TaskQueueService = TaskQueueService;
+class QueueTask extends _singleton.default {
+  queue;
+  worker;
+  initialize() {
+    this.queue = new _bullmq.Queue(this.getQueueName(), {
+      // Configurações do Redis
+      connection: {
+        host: 'localhost',
+        port: 6379
+      }
+    });
+    this.worker = new _bullmq.Worker(this.getQueueName(), this.handle.bind(this), {
+      connection: {
+        host: 'localhost',
+        port: 6379
+      }
+    });
+  }
+  async addJob(data) {
+    this.log('adicionando à fila...');
+    await this.queue.add(this.getQueueName(), data);
+  }
+  getQueue() {
+    return this.queue;
+  }
+  setQueue(queue) {
+    this.queue = queue;
+  }
+  getWorker() {
+    return this.worker;
+  }
+  setWorker(worker) {
+    this.worker = worker;
+  }
+  getActive() {
+    return this.active;
+  }
+  getQueueName() {
+    return this.queueName;
+  }
+}
+exports.QueueTask = QueueTask;