exodus-framework 2.0.955 → 2.0.956

package/lib/services/security.js

@@ -0,0 +1,231 @@
+"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 onStart() {
+    await super.onStart();
+    this.checkPaths();
+    await this.loadPrivateKey();
+    await this.loadPublicKey();
+    await this.loadServicePublicKey();
+    return true;
+  }
+  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,313 @@
+"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/classes/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 }; }
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+/**
+ * Serviço de gerênciamento do banco de dados
+ *
+ * @class SequelizeService
+ * @extends {Service}
+ * @deprecated Use {@link DatabaseService}
+ * @implements {IService}
+ */
+class SequelizeService extends _service.default {
+  serviceDB;
+  models;
+  connections;
+  initializedModels;
+  initializingdModels;
+  relations;
+  isReconnecting = false; // Flag para evitar múltiplas tentativas simultâneas de reconexão
+  isMasterConnected = false; // Flag para controlar o estado da conexão
+  isServiceConnected = false; // Flag para controlar o estado da conexão
+
+  //# Initialization
+  async onServiceInit() {
+    await super.onServiceInit();
+    if (!this.models) throw new Error('Models are requireds! Call registerModels(modelsArray)');
+    this.serviceDB = _database.mainDb;
+    this.connections = new Map();
+    this.initializedModels = new Map();
+    this.initializingdModels = new Map();
+    this.relations = new Map();
+    this.models = [...this.models, ..._models.NativeModels];
+    this.startAttemptDelay = 5 * 1000;
+    this.maxStartAttempts = 3;
+  }
+  async onStart() {
+    await super.onStart();
+    if (await this.connectDatabases()) {
+      this.log(`⌛️ Inicializando models`);
+      await this.initModels();
+      this.log(`✅ Models inicializados`);
+      return true;
+    }
+    return false;
+  }
+  async onStartFail() {
+    await super.onStartFail();
+    this.log(`Not possible to connect database`, 'danger');
+  }
+  async connectDatabases() {
+    if (this.isMasterConnected && this.isServiceConnected) return true;
+    if (this.isReconnecting) return false;
+    this.log(`⌛️ Connecting Sequelize to database: ${this.currentStartAttempts}/${this.maxStartAttempts}`);
+    try {
+      if (!this.isServiceConnected) {
+        await this.serviceDB.sync({
+          force: false
+        });
+        this.isServiceConnected = true;
+        this.log('✅ Connected service database sucessfully', 'success');
+      }
+      this.log('✅ All databases connecteds sucessfully', 'success');
+      return true;
+    } catch (error) {
+      (0, _logger.default)().error(error, `Not connected Sequelize to database`);
+      this.isReconnecting = false;
+      return false;
+    }
+  }
+
+  // #Database
+  async getDB(tenantId) {
+    /* master or service */
+    if (tenantId == _app.Core.settings.getDatabase().main.database) {
+      return _database.mainDb;
+    }
+    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().main.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().main.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().main.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) {
+    let connection = false;
+    if (tenantId == _app.Core.settings.getDatabase().main.database) {
+      connection = _database.mainDb;
+    } else {
+      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);
+      connection = await this.createConnection(relation.hostUuid, dbName);
+      if (connection) {
+        this.log(`✅ Connected ${dbName} database sucessfully`, 'success');
+        this.connections.set(key, connection);
+      }
+    }
+    if (connection) {
+      await this.initModelsByConnection(tenantId, connection);
+    }
+    return connection;
+  }
+  async initModelsByConnection(tenantId, connection) {
+    const entities = [];
+    await Promise.all(this.models.map(async model => {
+      const modelKey = `${tenantId}#${model.name}`;
+      const entity = model.initialize(connection);
+      await entity.sync();
+      entities.push(entity);
+      this.initializedModels.set(modelKey, entity);
+    }));
+    await Promise.all(this.models.map(async model => {
+      model.associate(entities);
+    }));
+  }
+  getDBName(envToken) {
+    return `${_app.Core.settings.getDatabase().main.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: _app.Core.settings.getDatabase().service.log
+    });
+    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',
+      pool: _app.Core.settings.getDatabase().service.pool,
+      logging: _app.Core.settings.getDatabase().service.log
+    });
+    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 {
+      const modelKey = `${tenantId}#${model.name}`;
+      if (!this.initializedModels.has(modelKey)) {
+        await this.initDB(tenantId);
+      }
+      return this.initializedModels.get(modelKey);
+    } catch (error) {
+      throw new _app.ErrorHandler('Erro ao obter o model', error);
+    }
+  }
+  static registerModels(models) {
+    this.getService().models = models;
+  }
+  async initModels() {
+    const tenants = await _models.EnvDBHost.findAll({
+      attributes: ['envUuid']
+    });
+    for (const model of this.models) {
+      await Promise.all(tenants.map(async t => await this.getModel(model, t.envUuid)));
+    }
+  }
+}
+var _default = exports.default = SequelizeService;

package/lib/services/socket.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _socket = require("socket.io");
+var _service = _interopRequireDefault(require("../app/classes/service"));
+var _controller = require("../app/controller");
+var _core = require("../contracts/core");
+var _authentication = require("../middlewares/authentication");
+var _express = _interopRequireDefault(require("./express"));
+var _utils = require("../utils");
+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;
+  eventhandlers;
+  clientHandlers = [];
+  async onServiceClusterInit() {
+    await super.onServiceClusterInit();
+    if (!this.mainRouter) throw new Error('Need router'); //!sem router
+
+    this.eventhandlers = new Map();
+  }
+  async onExodusClusterStarted() {
+    await super.onExodusClusterStarted();
+    //! este depende de ExpressService para iniciar, por isso está aqui
+
+    try {
+      this.createSocket(_express.default.getService().getHttpServer());
+      await this.registerHandlers();
+      this.server.on('connection', this.onConnection.bind(this));
+      this.log('✅ Socket server created');
+    } catch (error) {
+      (0, _utils.logger)().error(error, `Not connected to SocketIO`);
+    }
+  }
+  async onConnection(socket) {
+    this.log(`${socket.id} conectado`);
+    const request = new _controller.SocketRequest(socket);
+    const eventsH = Array.from(this.eventhandlers.values());
+    const clientsH = await Promise.all(this.clientHandlers.map(async E => {
+      const handler = new E();
+      await handler.onInit(request);
+      return handler;
+    }));
+    clientsH.forEach(handler => handler.onConnect());
+    const onAny = (event, ...args) => clientsH.forEach(handler => handler.onEvent(event, args));
+    socket.onAny(onAny);
+    eventsH.forEach(handlers => {
+      handlers.forEach(handler => handler.onConnect(request));
+    });
+    socket.on('disconnect', () => {
+      this.log(`${socket.id} desconectado`);
+      eventsH.forEach(handlers => {
+        handlers.forEach(handler => handler.onDisconnect(request));
+      });
+      clientsH.forEach(handler => handler.onDisconnect());
+      socket.offAny(onAny);
+    });
+    this.bindEvents(socket);
+  }
+  bindEvents(socket) {
+    const request = new _controller.SocketRequest(socket);
+    const handlers = Array.from(this.eventhandlers.entries());
+    for (const group of handlers) {
+      const event = group[0];
+      const handlers = group[1].filter(handler => {
+        let isSameSide = false;
+        switch (handler.getSide()) {
+          case _core.eExecutionSide.CLUSTER:
+            if (this.isCluster()) isSameSide = true;
+            break;
+          case _core.eExecutionSide.MASTER:
+            if (this.isMaster()) isSameSide = true;
+            break;
+          case _core.eExecutionSide.ANY:
+            isSameSide = true;
+            break;
+        }
+        return handler.getActive() && isSameSide;
+      });
+      socket.on(event, (...args) => {
+        handlers.forEach(handler => {
+          handler.onEvent(request, ...args);
+        });
+      });
+    }
+  }
+  createSocket(app, cors = {
+    origin: '*'
+  }) {
+    this.server = new _socket.Server(app, {
+      cors
+    });
+    const middleware = new _authentication.SocketAuthenticationMiddleware();
+    this.server.use(middleware.decryptToken);
+  }
+  static registerRouter(router) {
+    this.getService().mainRouter = router;
+  }
+  static registerClientHandlers(handlers) {
+    this.getService().clientHandlers = handlers;
+  }
+  async registerHandlers() {
+    return Promise.all(this.mainRouter.map(async handler => {
+      handler.onInit();
+      const event = handler.getEvent();
+      const group = this.eventhandlers.get(event) || [];
+      group.push(handler);
+      this.eventhandlers.set(event, group);
+    }));
+  }
+}
+var _default = exports.default = SocketIOService;

package/lib/services/task/TaskServiceBase.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _app = require("../../app");
+class TaskServiceBase extends _app.Service {
+  tasks = [];
+  static setTaskPath(path) {
+    this.getService().jobsPath = path;
+  }
+  static registerTask(task) {
+    this.getService().tasks.push(task);
+  }
+}
+var _default = exports.default = TaskServiceBase;