exodus-framework 2.0.953 → 2.0.955

package/lib/services/redis.js

@@ -1,84 +0,0 @@
-"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/classes/service"));
-var _cache = require("../app/classes/cache");
-var _utils = require("../utils");
-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;
-  isReconnecting = false; // Flag para evitar múltiplas tentativas simultâneas de reconexão
-  isConnected = false; // Flag para controlar o estado da conexão
-
-  async onServiceInit() {
-    await super.onServiceInit();
-    this.startAttemptDelay = 5 * 1000;
-    this.maxStartAttempts = 3;
-  }
-  async onStart() {
-    await super.onStart();
-    return this.connect();
-  }
-  async onStartFail() {
-    await super.onStartFail();
-    this.log(`Not possible to connect Redis`, 'danger');
-  }
-  async connect() {
-    if (this.isConnected) return true;
-    if (this.isReconnecting) return false;
-    this.log(`⌛️ Connecting to Redis Server: ${this.currentStartAttempts}/${this.maxStartAttempts}`);
-    this.isReconnecting = true;
-    try {
-      const queryConnect = `redis://${_app.Core.settings.getCache().host}:${_app.Core.settings.getCache().port}`;
-      const password = _app.Core.settings.getCache().password;
-      this.client = (0, _redis.createClient)({
-        url: queryConnect,
-        password
-      });
-      await this.client.connect();
-      this.isConnected = true;
-      this.isReconnecting = false;
-      this.setupErrorHandles();
-      this.log(`✅ Redis Connection is ready`);
-      return true;
-    } catch (error) {
-      (0, _utils.logger)().error(error, `Not connected to Redis Server`);
-      this.isReconnecting = false;
-      return false;
-    }
-  }
-  setupErrorHandles() {
-    this.client.on('error', err => {
-      new _app.ErrorHandler('falha na conexão Redis', err);
-      this.isConnected = false;
-    });
-  }
-
-  //* 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);
-  }
-  createCache(key) {
-    return new _cache.RedisCache(this.client, key);
-  }
-}
-var _default = exports.default = RedisService;

package/lib/services/security.js

@@ -1,231 +0,0 @@
-"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

@@ -1,323 +0,0 @@
-"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 }; }
-/**
- * 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;
-  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.serviceDB;
-    this.masterDB = _database.masterDB;
-    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.isMasterConnected) {
-        await this.masterDB.sync({
-          force: false
-        });
-        this.isMasterConnected = true;
-        this.log('✅ Connected master database sucessfully', 'success');
-      }
-      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().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) {
-    let connection = false;
-    if (tenantId == _app.Core.settings.getDatabase().service.database) {
-      connection = _database.serviceDB;
-    } else if (tenantId == _app.Core.settings.getDatabase().master.database) {
-      connection = _database.masterDB;
-    } 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().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: _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;