exodus-framework 2.0.953 → 2.0.955

package/lib/services/socket.js

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

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

package/lib/services/task/index.js

@@ -1,40 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _exportNames = {
-  TaskServiceBase: true
-};
-Object.defineProperty(exports, "TaskServiceBase", {
-  enumerable: true,
-  get: function () {
-    return _TaskServiceBase.default;
-  }
-});
-var _queue = require("./queue");
-Object.keys(_queue).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _queue[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _queue[key];
-    }
-  });
-});
-var _scheduler = require("./scheduler");
-Object.keys(_scheduler).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _scheduler[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _scheduler[key];
-    }
-  });
-});
-var _TaskServiceBase = _interopRequireDefault(require("./TaskServiceBase"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/services/task/queue/QueueService.js

@@ -1,48 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _bullmq = require("bullmq");
-var _app = require("../../../app");
-var _core = require("../../../contracts/core");
-var _TaskServiceBase = _interopRequireDefault(require("../TaskServiceBase"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-//* Queue
-class QueueTaskService extends _TaskServiceBase.default {
-  connection;
-  async onStart() {
-    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');
-    for (const task of this.tasks) {
-      this.startTask(task.singleton());
-    }
-    this.log('All jobs initializeds', 'info');
-    return true;
-  }
-  async startTask(task) {
-    task.taskInit();
-    if (!task.getActive()) return;
-    if (task.getSide() === _core.eExecutionSide.ANY || task.getSide() === _core.eExecutionSide.CLUSTER && this.isCluster() || task.getSide() === _core.eExecutionSide.MASTER && this.isMaster()) {
-      const worker = new _bullmq.Worker(task.getName(), task.execute.bind(task), {
-        connection: this.connection,
-        concurrency: task.getConcurrency()
-      });
-      task.setWorker(worker);
-    }
-    const queue = new _bullmq.Queue(task.getName(), {
-      connection: this.connection
-    });
-    task.setQueue(queue);
-    this.log(`Task '${task.getName()}' started...`, 'warning');
-  }
-  getCacheConnection() {
-    return this.connection;
-  }
-}
-var _default = exports.default = QueueTaskService;

package/lib/services/task/queue/QueueTask.js

@@ -1,134 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _app = require("../../../app");
-var _communication = _interopRequireDefault(require("../../../app/classes/communication"));
-var _service = require("../../../contracts/service");
-var _core = require("../../../contracts/core");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-class QueueTask extends _app.Singleton {
-  rECom;
-  queue;
-  worker;
-  side;
-  name;
-  active;
-  concurrency;
-
-  //# Init
-  async taskInit() {
-    this.rECom = new _communication.default(this.constructor.name);
-    this.rECom.on(_service.eEventCommunication.RECEIVED_CLUSTER_MESSAGE, this.onTaskMasterReceived.bind(this));
-    this.rECom.on(_service.eEventCommunication.RECEIVED_MASTER_MESSAGE, this.onTaskClusterReceived.bind(this));
-    this.side = _core.eExecutionSide.ANY;
-    this.name = this.constructor.name;
-    this.active = true;
-    this.concurrency = 1;
-    this.onTaskInit();
-    if (this.isMaster()) {
-      this.onTaskMasterInit();
-    }
-    if (this.isCluster()) {
-      this.onTaskClusterInit();
-    }
-  }
-
-  //# Getters
-  getQueue() {
-    return this.queue;
-  }
-  getWorker() {
-    return (this.side === _core.eExecutionSide.ANY || this.side === _core.eExecutionSide.CLUSTER && this.isCluster() || this.side === _core.eExecutionSide.MASTER && this.isMaster()) && this.worker != undefined;
-  }
-  getActive() {
-    return this.active;
-  }
-  getName() {
-    return this.name;
-  }
-  getSide() {
-    return this.side;
-  }
-  getConcurrency() {
-    return this.concurrency;
-  }
-
-  //# Setters
-  setQueue(queue) {
-    this.queue = queue;
-  }
-  setWorker(worker) {
-    this.worker = worker;
-  }
-
-  //# Basic Handlers
-  execute(job, token) {
-    this.onExecute(job, token);
-    if (this.isCluster()) {
-      this.onClusterExecute(job, token);
-    }
-    if (this.isMaster()) {
-      this.onMasterExecute(job, token);
-    }
-  }
-  async addJob(data) {
-    if (!this.getActive()) {
-      new _app.ErrorHandler('falha ao adicionar uma tarefa', new Error('A task não está ativa'));
-      return;
-    }
-    if (!this.getQueue()) {
-      new _app.ErrorHandler('falha ao adicionar uma tarefa', new Error('A task não está pronta'));
-      return;
-    }
-    await this.queue.add(this.getName(), data);
-    this.onNewJob(data);
-    // this.log('Nova tarefa disponível.', 'comment');
-  }
-  static async addJob(data) {
-    this.singleton().addJob(data);
-  }
-
-  //# Events
-  onTaskInit() {
-    return;
-  }
-  onTaskClusterInit() {
-    return;
-  }
-  onTaskMasterInit() {
-    return;
-  }
-  //----------------------------------------------------------------------------
-  onTaskMasterReceived(_worker, _eventKey, _data) {
-    return;
-  }
-  onTaskClusterReceived(_eventKey, _data) {
-    return;
-  }
-  //----------------------------------------------------------------------------
-  onClusterExecute(_job, _token) {
-    return;
-  }
-  onMasterExecute(_job, _token) {
-    return;
-  }
-  onExecute(_job, _token) {
-    return;
-  }
-  //----------------------------------------------------------------------------
-  onNewJob(_data) {
-    return;
-  }
-
-  //# Managed
-  sendTaskToCluster(clusterId, event, data) {
-    this.rECom.sendMessageToCluster(clusterId, event, data);
-  }
-  sendTaskToMaster(event, data) {
-    this.rECom.sendMessageToMaster(event, data);
-  }
-}
-var _default = exports.default = QueueTask;

package/lib/services/task/queue/SingleQueue.js

@@ -1,68 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _bullmq = require("bullmq");
-var _system = _interopRequireDefault(require("../../../app/classes/system"));
-var _QueueService = _interopRequireDefault(require("./QueueService"));
-var _app = require("../../../app");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-class SingleQueue extends _system.default {
-  worker;
-  queue;
-  concurrency = 1;
-  name;
-  onTick;
-  constructor(cacheKey) {
-    super();
-    this.cacheKey = cacheKey;
-    this.name = `${this.constructor.name}.${this.cacheKey}`;
-  }
-  start() {
-    this.createWorker();
-    this.createQueue();
-  }
-  createQueue() {
-    this.queue = new _bullmq.Queue(this.name, {
-      connection: _QueueService.default.getService().getCacheConnection()
-    });
-  }
-  createWorker() {
-    this.worker = new _bullmq.Worker(this.name, this.tick.bind(this), {
-      connection: _QueueService.default.getService().getCacheConnection(),
-      concurrency: this.concurrency
-    });
-  }
-  setConcurrency(concurrency) {
-    if (concurrency < 1) concurrency = 1;
-    this.concurrency = concurrency;
-  }
-  async tick(job, _token) {
-    if (!this.onTick) return;
-    const {
-      data
-    } = job;
-    await this.onTick(data);
-  }
-  setTick(cb) {
-    this.onTick = cb;
-  }
-  async addJob(data) {
-    if (!this.queue) {
-      new _app.ErrorHandler('falha ao adicionar uma tarefa', new Error('A task não está pronta'));
-      return;
-    }
-    await this.queue.add(this.name, data);
-  }
-  pauseQueue() {
-    if (!this.queue) return;
-    this.queue.pause();
-  }
-  resumeQueue() {
-    if (!this.queue) return;
-    this.queue.resume();
-  }
-}
-var _default = exports.default = SingleQueue;

package/lib/services/task/queue/index.js

@@ -1,27 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "QueueTask", {
-  enumerable: true,
-  get: function () {
-    return _QueueTask.default;
-  }
-});
-Object.defineProperty(exports, "QueueTaskService", {
-  enumerable: true,
-  get: function () {
-    return _QueueService.default;
-  }
-});
-Object.defineProperty(exports, "SingleQueue", {
-  enumerable: true,
-  get: function () {
-    return _SingleQueue.default;
-  }
-});
-var _QueueService = _interopRequireDefault(require("./QueueService"));
-var _QueueTask = _interopRequireDefault(require("./QueueTask"));
-var _SingleQueue = _interopRequireDefault(require("./SingleQueue"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/services/task/scheduler/SchedulerService.js

@@ -1,31 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _nodeSchedule = require("node-schedule");
-var _core = require("../../../contracts/core");
-var _TaskServiceBase = _interopRequireDefault(require("../TaskServiceBase"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-class SchedulerTaskService extends _TaskServiceBase.default {
-  async onStart() {
-    this.log('Initializing taks...');
-    for (const task of this.tasks) {
-      const intanceTask = task.singleton();
-      this.startTask(intanceTask);
-    }
-    return true;
-  }
-  async startTask(task) {
-    await task.taskInit();
-    if (!task.getActive()) return;
-    if (task.getSide() === _core.eExecutionSide.ANY || task.getSide() === _core.eExecutionSide.CLUSTER && this.isCluster() || task.getSide() === _core.eExecutionSide.MASTER && this.isMaster()) {
-      if (task.isImmediate()) task.execute();
-      const job = (0, _nodeSchedule.scheduleJob)(task.getCronTask(), task.execute.bind(task));
-      task.setJob(job);
-    }
-    this.log(`Job '${task.getName()}' started...`, 'warning');
-  }
-}
-var _default = exports.default = SchedulerTaskService;

package/lib/services/task/scheduler/SchedulerTask.js

@@ -1,211 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _app = require("../../../app");
-var _contansts = require("../../../contracts/contansts");
-var _service = require("../../../contracts/service");
-var _communication = _interopRequireDefault(require("../../../app/classes/communication"));
-var _core = require("../../../contracts/core");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-class ScheduleTask extends _app.Singleton {
-  rECom;
-  workPerCluster = new Map();
-  lastDesignatedClusterId = 0;
-  registeredClusters = new Map();
-  cron;
-  active;
-  name;
-  side;
-  job;
-  /**
-   * Deve ser executada imediatamente e depois agendada?
-   *
-   * @protected
-   * @type {boolean}
-   * @memberof ScheduleTask
-   */
-  immediate;
-  /**
-   * Esta task deve ficar ativa ou parada após a execução?
-   * Tenha em mente que se/também immediate = true, esta task será executada apenas na
-   * inicialização do Exodus
-   *
-   * @protected
-   * @type {boolean}
-   * @memberof ScheduleTask
-   */
-  persistent;
-  async execute() {
-    this.onExecute();
-    if (this.isCluster()) {
-      this.onClusterExecute();
-    }
-    if (this.isMaster()) {
-      this.onMasterExecute();
-    }
-    if (!this.persistent) this.job.cancel();
-  }
-  async taskInit() {
-    this.cron = _contansts.eScheduleTaskInterval.DEFAULT;
-    this.active = true;
-    this.name = this.constructor.name;
-    this.side = _core.eExecutionSide.ANY;
-    this.immediate = false;
-    this.persistent = true;
-    this.rECom = new _communication.default(this.name);
-    this.rECom.on(_service.eEventCommunication.RECEIVED_CLUSTER_MESSAGE, this.taskMasterReceived.bind(this));
-    this.rECom.on(_service.eEventCommunication.RECEIVED_MASTER_MESSAGE, this.taskClusterReceived.bind(this));
-    this.onTaskInit();
-    if (this.isMaster()) {
-      this.onTaskMasterInit();
-    }
-    if (this.isCluster()) {
-      this.onTaskClusterInit();
-      this.sendToTaskMaster('task.init', {});
-    }
-  }
-  sendToTaskCluster(clusterId, event, data) {
-    this.rECom.sendToServiceCluster(clusterId, event, data);
-  }
-  sendToTaskMaster(event, data) {
-    this.rECom.sendToServiceMaster(event, data);
-  }
-
-  //# Muted methods
-  onTaskInit() {
-    return;
-  }
-  onTaskClusterInit() {
-    return;
-  }
-  onTaskMasterInit() {
-    return;
-  }
-  getCronTask() {
-    return this.cron;
-  }
-  getActive() {
-    return this.active;
-  }
-  getName() {
-    return this.name;
-  }
-  getSide() {
-    return this.side;
-  }
-  isImmediate() {
-    return this.immediate;
-  }
-  setJob(job) {
-    if (this.job) return;
-    this.job = job;
-  }
-  onExecute() {
-    return;
-  }
-  onClusterExecute() {
-    return;
-  }
-  onMasterExecute() {
-    return;
-  }
-  addTaskWork(workId, workData) {
-    if (this.isCluster()) {
-      this.sendTaskWorkToMaster(workId, workData);
-    } else {
-      this.sendTaskWorkToCluster(workId, workData);
-    }
-  }
-
-  //# Cluster
-  sendTaskWorkToMaster(workId, workData) {
-    this.sendToTaskMaster('work.add', {
-      workId,
-      workData
-    });
-  }
-  taskClusterReceived(eventKey, data) {
-    switch (eventKey) {
-      case 'work.add':
-        this.onTaskClusterReceivedWork(eventKey, data);
-        break;
-      default:
-        this.onTaskClusterReceivedData(eventKey, data);
-        break;
-    }
-  }
-  onTaskClusterReceivedData(_eventKey, _data) {
-    return;
-  }
-  onTaskClusterReceivedWork(_eventKey, _data) {
-    return;
-  }
-
-  //# Master
-  taskMasterReceived(worker, eventKey, data) {
-    switch (eventKey) {
-      case 'work.add':
-        this.onTaskMasterReceivedWork(worker, eventKey, data);
-        break;
-      case 'work.add.accepted':
-        this.onTaskMasterAcceptedWork(worker, eventKey, data);
-        break;
-      case 'task.init':
-        this.taskClusterRegistered(worker);
-        break;
-      default:
-        this.onTaskMasterReceived(worker, eventKey, data);
-        break;
-    }
-  }
-  onTaskMasterReceived(worker, eventKey, data) {
-    switch (eventKey) {
-      case 'work.add':
-        this.onTaskMasterReceivedWork(worker, eventKey, data);
-        break;
-      case 'work.add.accepted':
-        this.onTaskMasterAcceptedWork(worker, eventKey, data);
-        break;
-      default:
-        console.log('mensagem desconhecida recebida', eventKey);
-        break;
-    }
-  }
-  onTaskMasterReceivedWork(_worker, _eventKey, _data) {
-    return;
-  }
-  onTaskMasterAcceptedWork(_worker, _eventKey, _data) {
-    return;
-  }
-  sendTaskWorkToCluster(workId, workData) {
-    const total = this.getClusterCount();
-    if (!this.workPerCluster.has(workId)) {
-      const nextCluster = this.lastDesignatedClusterId + 1 > total ? 1 : this.lastDesignatedClusterId + 1;
-      this.sendToTaskCluster(nextCluster, 'work.add', {
-        workId,
-        workData
-      });
-    }
-  }
-  onClusterDown(_, worker) {
-    if (this.registeredClusters.has(worker.id)) {
-      // console.log('removendo cluster da lista de registrados');
-      this.registeredClusters.delete(worker.id);
-    }
-  }
-  taskClusterRegistered(_worker) {
-    if (!this.registeredClusters.has(_worker.id)) {
-      // console.log('registrando novo cluster', _worker.id);
-
-      this.registeredClusters.set(_worker.id, true);
-    }
-    this.onTaskClusterRegistered(_worker);
-  }
-  onTaskClusterRegistered(_worker) {
-    return;
-  }
-}
-var _default = exports.default = ScheduleTask;