exodus-framework 2.0.755 → 2.0.756

package/lib/services/sequelize.js

@@ -1,284 +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/service"));
-var _models = require("../models");
-var _DatabaseHost = require("../models/DatabaseHost");
-var _database = require("../utils/database");
-var _logger = _interopRequireDefault(require("../utils/logger"));
-var _error = require("./error");
-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.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);
-      });
-    });
-  }
-
-  // #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 _error.ApplicationException('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 _error.ApplicationException('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 _error.ApplicationException('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 _error.ApplicationException('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;

package/lib/services/socket.js

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

@@ -1,165 +0,0 @@
-"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) {
-      this.startTask(job);
-    }
-  }
-  async startTask(task) {
-    if (!task.getActive()) return;
-    const queue = new _bullmq.Queue(task.getQueueName(), {
-      connection: this.connection
-    });
-    const worker = new _bullmq.Worker(task.getQueueName(), task.handle.bind(task), {
-      connection: this.connection
-    });
-    task.setQueue(queue);
-    task.setWorker(worker);
-    task.init();
-    this.log(`Job '${task.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) {
-    await this.queue.add(this.getQueueName(), data);
-    this.log('Nova tarefa disponível.', 'comment');
-  }
-  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;

package/lib/utils/api.js

@@ -1,50 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _core = _interopRequireDefault(require("../app/core"));
-var _error = require("../services/error");
-var _axios = _interopRequireDefault(require("axios"));
-var _dateFns = require("date-fns");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-class Api extends _core.default {
-  axios;
-  constructor() {
-    super();
-    this.init();
-  }
-  async init() {
-    this.axios = _axios.default.create({
-      baseURL: this.host,
-      headers: {
-        ...this.headers,
-        'Content-Type': 'application/json'
-      },
-      validateStatus: this.validateStatus
-    });
-  }
-  async request(endpoint, method, data, params, headers) {
-    try {
-      const res = await this.axios({
-        method,
-        url: this.host + endpoint,
-        data,
-        params,
-        headers: {
-          ...headers,
-          ...this.headers
-        }
-      });
-      return res.data;
-    } catch (error) {
-      new _error.ApplicationException('não foi possível realizar uma requisição', error);
-    }
-  }
-  getLogicalSecurityId() {
-    const date = (0, _dateFns.format)(new Date(), 'yyyy-MM-dd');
-    return String(Date.parse(date) - 5000);
-  }
-}
-var _default = exports.default = Api;

package/lib/utils/database.js

@@ -1,157 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.masterDB = void 0;
-exports.processFilters = processFilters;
-exports.serviceDB = void 0;
-var _sequelize = require("sequelize");
-var _app = require("../app");
-var _logger = _interopRequireDefault(require("./logger"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const serviceDB = exports.serviceDB = new _sequelize.Sequelize({
-  database: _app.Core.settings.getDatabase().service.database,
-  dialect: _app.Core.settings.getDatabase().master.dialect,
-  username: _app.Core.settings.getDatabase().master.username,
-  password: _app.Core.settings.getDatabase().master.password,
-  define: {
-    timestamps: true
-  },
-  timezone: '-03:00',
-  logging(sql, timing) {
-    (0, _logger.default)().trace('DATABASE', sql, timing);
-  }
-});
-const masterDB = exports.masterDB = new _sequelize.Sequelize({
-  database: _app.Core.settings.getDatabase().master.database,
-  dialect: _app.Core.settings.getDatabase().master.dialect,
-  username: _app.Core.settings.getDatabase().master.username,
-  password: _app.Core.settings.getDatabase().master.password,
-  define: {
-    timestamps: true
-  },
-  timezone: '-03:00',
-  logging(sql, timing) {
-    (0, _logger.default)().trace('DATABASE', sql, timing);
-  }
-});
-function processCondition(cond) {
-  if ('or' in cond) {
-    return {
-      [_sequelize.Op.or]: cond.or.map(subCond => processCondition(subCond))
-    };
-  }
-  if ('and' in cond) {
-    return {
-      [_sequelize.Op.and]: cond.and.map(subCond => processCondition(subCond))
-    };
-  }
-  const simpleWhere = {};
-  if (cond.eq !== undefined) {
-    simpleWhere[_sequelize.Op.eq] = cond.type === 'DATE' ? new Date(cond.eq) : cond.eq;
-  }
-  if (cond.gt !== undefined) {
-    simpleWhere[_sequelize.Op.gt] = cond.type === 'DATE' ? new Date(cond.eq) : cond.gt;
-  }
-  if (cond.lt !== undefined) {
-    simpleWhere[_sequelize.Op.lt] = cond.type === 'DATE' ? new Date(cond.lt) : cond.lt;
-  }
-  if (cond.between !== undefined) {
-    simpleWhere[_sequelize.Op.between] = cond.type === 'DATE' ? cond.between.map(d => new Date(d)) : cond.between;
-  }
-  if (cond.notBetween !== undefined) {
-    simpleWhere[_sequelize.Op.notBetween] = cond.type === 'DATE' ? cond.notBetween.map(d => new Date(d)) : cond.notBetween;
-  }
-  if (cond.like !== undefined) {
-    simpleWhere[_sequelize.Op.like] = cond.type === 'DATE' ? new Date(cond.like) : cond.like;
-  }
-  if (cond.notLike !== undefined) {
-    simpleWhere[_sequelize.Op.notLike] = cond.type === 'DATE' ? new Date(cond.notLike) : cond.notLike;
-  }
-  if (cond.in !== undefined) {
-    simpleWhere[_sequelize.Op.in] = cond.type === 'DATE' ? cond.in.map(d => new Date(d)) : cond.in;
-  }
-  if (cond.notIn !== undefined) {
-    simpleWhere[_sequelize.Op.notIn] = cond.type === 'DATE' ? cond.notIn.map(d => new Date(d)) : cond.notIn;
-  }
-  return simpleWhere;
-}
-function processDateCondition(key, cond) {
-  const simpleWhere = [key, undefined];
-  if (cond.eq !== undefined) {
-    simpleWhere[0] = _sequelize.Op.and;
-    simpleWhere[1] = [(0, _sequelize.literal)(`DATE(${key}) = '${cond.eq}'`)];
-  }
-  if (cond.gt !== undefined) {
-    simpleWhere[0] = _sequelize.Op.and;
-    simpleWhere[1] = [(0, _sequelize.literal)(`DATE(${key}) > '${cond.gt}'`)];
-  }
-  if (cond.lt !== undefined) {
-    simpleWhere[0] = _sequelize.Op.and;
-    simpleWhere[1] = [(0, _sequelize.literal)(`DATE(${key}) < '${cond.lt}'`)];
-  }
-  if (cond.between !== undefined) {
-    simpleWhere[1] = {
-      [_sequelize.Op.between]: cond.between.map(d => new Date(d))
-    };
-  }
-  if (cond.notBetween !== undefined) {
-    simpleWhere[1] = {
-      [_sequelize.Op.notBetween]: cond.notBetween.map(d => new Date(d))
-    };
-  }
-  if (cond.in !== undefined) {
-    simpleWhere[1] = {
-      [_sequelize.Op.in]: cond.in.map(d => new Date(d))
-    };
-  }
-  if (cond.notIn !== undefined) {
-    simpleWhere[1] = {
-      [_sequelize.Op.notIn]: cond.notIn.map(d => new Date(d))
-    };
-  }
-  return simpleWhere;
-}
-
-// Função Principal para Processar Filtros
-function processFilters(filters) {
-  if (!filters) return {};
-  const where = {};
-  Object.entries(filters).forEach(([key, condition]) => {
-    if (key === 'or' || key === 'and') {
-      const logicalOp = key === 'or' ? _sequelize.Op.or : _sequelize.Op.and;
-      const t = [];
-      for (const c of condition) {
-        const [[key, value]] = Object.entries(c);
-        t.push({
-          [key]: processCondition(value)
-        });
-      }
-      if (!where[logicalOp]) {
-        where[logicalOp] = [];
-      }
-      where[logicalOp].push(...t);
-    } else {
-      const field = key;
-      const isDate = condition.type && condition.type === 'DATE';
-      const isTime = condition.type && condition.type === 'TIME';
-      const isDateTime = condition.type && condition.type === 'DATETIME';
-      if (isDate) {
-        const [k, c] = processDateCondition(key, condition);
-        where[k] = c;
-      } else {
-        const processedCondition = processCondition(condition);
-        if (where[field]) {
-          where[field] = {
-            ...where[field],
-            ...processedCondition
-          };
-        } else {
-          where[field] = processedCondition;
-        }
-      }
-    }
-  });
-  return where;
-}