exodus-framework 2.0.955 → 2.0.956

package/lib/app/classes/service.js

@@ -0,0 +1,232 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _service = require("../../contracts/service");
+var _communication = _interopRequireDefault(require("./communication"));
+var _managed = _interopRequireDefault(require("./managed"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Classe base de Serviços
+ * Responsável por gerênciar métodos e funções utilizadas por todas
+ * as classes de serviço desta aplicação
+ *
+ * @abstract
+ * @class Service
+ * @extends {Managed}
+ * @template S
+ */
+class Service extends _managed.default {
+  static instance;
+  eCom;
+  startAttemptDelay = 1000; // Tempo de espera para cada tentativa de inicialização
+  maxStartAttempts = 3; // Numero de tentativas máximas para iniciar o serviço
+  currentStartAttempts = 1; // Numero de tentativas atual para iniciar o serviço
+
+  constructor() {
+    super();
+    this.eCom = new _communication.default(this.constructor.name);
+  }
+
+  /**
+   * Mesmo que getService
+   *
+   * @deprecated Use getService
+   * @static
+   * @template S
+   * @param {TStaticService<S>} this
+   * @memberof Service
+   */
+  static singleton() {
+    if (!this.instance) this.instance = new this();
+    return this.instance;
+  }
+  /**
+   * Obtem a instância atual deste serviço
+   *
+   * @static
+   * @template S
+   * @param {TStaticService<S>} this
+   * @memberof Service
+   */
+  static getService() {
+    return this.singleton();
+  }
+
+  /**
+   * Chamado antes de onStart, serve como preparação para a inicialização do serviços
+   * pré fetchs e etc...
+   * Diferente de onStart, este é chamado apenas uma vez
+   *
+   * @public
+   * @memberof Service
+   */
+  async onServiceInit() {
+    this.eCom.on(_service.eEventCommunication.RECEIVED_CLUSTER_MESSAGE, this.onServiceMasterReceived.bind(this));
+    this.eCom.on(_service.eEventCommunication.RECEIVED_MASTER_MESSAGE, this.onServiceClusterReceived.bind(this));
+    if (this.isMaster()) {
+      await this.onServiceMasterInit();
+    }
+    if (this.isCluster()) {
+      await this.onServiceClusterInit();
+    }
+  }
+  /**
+   * Mesmo que onServiceInit, mas do lado do master
+   *
+   * @protected
+   * @memberof Service
+   */
+  async onServiceMasterInit() {
+    return;
+  }
+  /**
+   * Mesmo que onServiceInit, mas do lado do cluster
+   *
+   * @protected
+   * @memberof Service
+   */
+  async onServiceClusterInit() {
+    return;
+  }
+
+  // !future
+  /**
+   * Inicia o procedimento de inicialização do seriviço
+   * usado para conexões, fetchs e etc...
+   *
+   * @return {*}  {Promise<boolean>}
+   * @memberof Service
+   */
+  async onStart() {
+    if (this.isMaster()) {
+      return this.onStartMaster();
+    }
+    if (this.isCluster()) {
+      return this.onStartCluster();
+    }
+    return true;
+  }
+  async onStartMaster() {
+    return true;
+  }
+  async onStartCluster() {
+    return true;
+  }
+  /**
+   * Quando uma nova tentativa de inicialização é executada
+   *
+   * @memberof Service
+   */
+  async onStartAttempt() {
+    this.currentStartAttempts += 1;
+  }
+  /**
+   * Executado quando a inicialização deste serviço falhar
+   *
+   * @memberof Service
+   */
+  async onStartFail() {
+    // this.log(`Erro on init this service.`, 'danger');
+  }
+  /**
+   * Quando o serviço inicializar com sucesso
+   *
+   * @memberof Service
+   */
+  async onStartSuccessfully() {
+    this.currentStartAttempts = 1;
+  }
+  /**
+   * Quando todos os serviços foram carregados
+   * Pode ser usado para eliminar dados utilizados na inicialização
+   *
+   * @memberof Service
+   */
+  async onExodusStarted() {
+    if (this.isMaster()) {
+      await this.onExodusMasterStarted();
+    }
+    if (this.isCluster()) {
+      await this.onExodusClusterStarted();
+    }
+  }
+  /**
+   * Mesmo que onExodusStarted mas no master
+   *
+   * @memberof Service
+   */
+  async onExodusMasterStarted() {}
+  /**
+   * Mesmo que onExodusStarted mas no cluster
+   *
+   * @memberof Service
+   */
+  async onExodusClusterStarted() {}
+
+  /**
+   * Enviar dados para a instância deste serviço no cluster
+   *
+   * @protected
+   * @param {number} clusterId
+   * @param {string} event
+   * @param {D} data
+   * @memberof Service
+   */
+  sendToServiceCluster(clusterId, event, data) {
+    this.eCom.sendMessageToCluster(clusterId, event, data);
+  }
+
+  /**
+   * Enviar dados para a instancia deste serviço no master
+   *
+   * @protected
+   * @param {string} event
+   * @param {D} data
+   * @memberof Service
+   */
+  sendToServiceMaster(event, data) {
+    this.eCom.sendMessageToMaster(event, data);
+  }
+
+  /**
+   * Quando dados enviados do serviço no master para a instância no cluster
+   *
+   * @protected
+   * @param {Worker} _worker
+   * @param {string} _eventKey
+   * @param {*} _data
+   * @memberof Service
+   */
+  onServiceMasterReceived(_worker, _eventKey, _data) {
+    return;
+  }
+  /**
+   * Quando dados enviados do serviço no cluster para a instância no master
+   *
+   * @protected
+   * @param {string} _eventKey
+   * @param {*} _data
+   * @memberof Service
+   */
+  onServiceClusterReceived(_eventKey, _data) {
+    return;
+  }
+
+  /**
+   * Reporta a condição de inicialização falhou
+   * se verdadeiro, o Exodus irá cancelar a inicialização deste serviço e chamar onStartFail
+   *
+   * @return {*}  {boolean}
+   * @memberof Service
+   */
+  isStartFailed() {
+    return this.currentStartAttempts > this.maxStartAttempts;
+  }
+  getAttemptDelay() {
+    return this.startAttemptDelay;
+  }
+}
+var _default = exports.default = Service;

package/lib/app/classes/servicemodel.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _sequelize = require("sequelize");
+class ServiceModel extends _sequelize.Model {
+  static initialize(connection) {
+    return connection.define(this.name, this.getEntityParams(), this.getConnParams());
+  }
+  static async associate(_models) {
+    return;
+  }
+  static getEntityParams() {
+    throw new Error('Entity params não definido');
+  }
+  static getConnParams() {
+    throw new Error('Entity Connection params não definido');
+  }
+}
+var _default = exports.default = ServiceModel;

package/lib/app/classes/singleton.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _managed = _interopRequireDefault(require("./managed"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Classe base para gerênciamento de instancia Singleton
+ * Usada para possibilitar a classe filha de manipular a
+ * instancia de sí mesma
+ *
+ * @abstract
+ * @class Singleton
+ * @extends {Managed}
+ */
+class Singleton extends _managed.default {
+  // #Singleton
+  static instance;
+  static singleton() {
+    if (!this.instance) this.instance = new this();
+    return this.instance;
+  }
+}
+var _default = exports.default = Singleton;

package/lib/app/classes/socket/clienthandler.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _core = require("../../../contracts/core");
+var _system = _interopRequireDefault(require("../system"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class SocketClientHandler extends _system.default {
+  side;
+  name;
+  active;
+  request;
+  requestor;
+  tenantId;
+  account;
+  isApplication;
+  async onInit(request) {
+    this.side = _core.eExecutionSide.ANY;
+    this.name = this.constructor.name;
+    this.active = true;
+    this.request = request;
+    this.requestor = request.requestor;
+    this.tenantId = request.tenant.id;
+    this.account = request.auth.account;
+    this.isApplication = request.isApplication;
+  }
+
+  /* Connection */
+  onConnect() {}
+  onDisconnect() {}
+
+  /* Event Handler */
+  onEvent(_event, ..._args) {}
+
+  //# Getters
+  getSide() {
+    return this.side;
+  }
+  getName() {
+    return this.name;
+  }
+  getActive() {
+    return this.active;
+  }
+  getRequester() {
+    return this.request;
+  }
+  send(event, ...args) {
+    this.request.send(event, ...args);
+  }
+}
+var _default = exports.default = SocketClientHandler;

package/lib/app/classes/socket/eventhandler.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _core = require("../../../contracts/core");
+var _system = _interopRequireDefault(require("../system"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class SocketEventHandler extends _system.default {
+  event;
+  side;
+  name;
+  active;
+  requesters;
+  onInit() {
+    this.side = _core.eExecutionSide.ANY;
+    this.name = this.constructor.name;
+    this.active = true;
+    this.requesters = new Map();
+  }
+
+  /* Connection */
+  onConnect(request) {
+    this.requesters.set(request.requestor.id, request);
+  }
+  onDisconnect(request) {
+    this.requesters.delete(request.requestor.id);
+  }
+
+  /* Event Handler */
+  onEvent(_request, ..._args) {}
+
+  //# Getters
+  getEvent() {
+    return this.event;
+  }
+  getSide() {
+    return this.side;
+  }
+  getName() {
+    return this.name;
+  }
+  getActive() {
+    return this.active;
+  }
+  getRequester(id) {
+    return this.requesters.get(id);
+  }
+}
+var _default = exports.default = SocketEventHandler;

package/lib/app/classes/socket/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "SocketClientHandler", {
+  enumerable: true,
+  get: function () {
+    return _clienthandler.default;
+  }
+});
+Object.defineProperty(exports, "SocketEventHandler", {
+  enumerable: true,
+  get: function () {
+    return _eventhandler.default;
+  }
+});
+var _eventhandler = _interopRequireDefault(require("./eventhandler"));
+var _clienthandler = _interopRequireDefault(require("./clienthandler"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/app/classes/system.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _cluster = _interopRequireDefault(require("cluster"));
+var _dateFns = require("date-fns");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class System {
+  log(msg, level = 'normal') {
+    if (!msg) return;
+    let query = '\x1b[97m[%s]';
+    const params = [(0, _dateFns.format)(new Date(), 'HH:mm:ss')];
+    if (_cluster.default.isWorker) {
+      query = query + `\x1b[96m[%s]`;
+      params.push(`Cluster${_cluster.default.worker.id}`);
+    }
+    query = query + `\x1b[33m[%s]`;
+    params.push(this.constructor.name || 'unknow');
+    switch (level) {
+      case 'info':
+        query = query + `\x1b[94m `;
+        break;
+      case 'danger':
+        query = query + `\x1b[91m `;
+        break;
+      case 'warning':
+        query = query + `\x1b[33m `;
+        break;
+      case 'success':
+        query = query + `\x1b[92m `;
+        break;
+      case 'especial':
+        query = query + `\x1b[95m `;
+        break;
+      case 'comment':
+        query = query + `\x1b[97m `;
+        break;
+      case 'normal':
+        query = query + `\x1b[0m `;
+        break;
+    }
+    query = query + `%s\x1b[0m`;
+    params.push(msg);
+    console.log(query, ...params);
+  }
+}
+var _default = exports.default = System;

package/lib/app/controller.js

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SocketRequest = exports.SocketController = exports.MessagingController = exports.HttpController = void 0;
+var _express = _interopRequireDefault(require("../services/express"));
+var _system = _interopRequireDefault(require("./classes/system"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Classe base dos conttrolers http
+ *
+ * @abstract
+ * @class Controller
+ * @extends {System}
+ */
+class HttpController extends _system.default {
+  constructor() {
+    super();
+  }
+
+  /**
+   * Metódo de envio de respostar http para o cliente
+   *
+   * @protected
+   * @param {THttpResponse} objResponse
+   * @param {Response} res
+   * @param {NextFunction} [next]
+   * @return {void}
+   * @memberof Controller
+   */
+  send(objResponse, res, next) {
+    return _express.default.singleton().sendResponse(objResponse, res, next);
+  }
+  validate(data) {
+    return _express.default.singleton().checkRequest(data);
+  }
+}
+
+/**
+ * Class base dos controllers SocketIO
+ *
+ * @export
+ * @abstract
+ * @class SocketController
+ * @extends {System}
+ */
+exports.HttpController = HttpController;
+class SocketController extends _system.default {
+  constructor() {
+    super();
+  }
+  handlerEventBind(cb) {
+    return (req, data) => {
+      const d = this.bufferToData(data);
+      cb(req, ...d);
+    };
+  }
+  bufferToData(data) {
+    return Array.from(data);
+  }
+}
+exports.SocketController = SocketController;
+class SocketRequest extends _system.default {
+  auth;
+  tenant;
+  requestor;
+  isApplication;
+  constructor(socket) {
+    super();
+    this.socket = socket;
+    this.auth = this.socket.auth;
+    this.tenant = this.socket.tenant;
+    this.requestor = this.socket.requestor;
+    this.isApplication = this.socket.isApplication;
+  }
+  send(event, ...data) {
+    this.socket.emit(event, ...data);
+  }
+  getSocket() {
+    return this.socket;
+  }
+  dataToBuffer(data) {
+    return Buffer.from(data, 'utf-8');
+  }
+}
+exports.SocketRequest = SocketRequest;
+class MessagingController extends _system.default {
+  constructor() {
+    super();
+  }
+  bufferToData(data) {
+    return Array.from(data);
+  }
+}
+exports.MessagingController = MessagingController;
+var _default = exports.default = HttpController;

package/lib/app/core.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var fs = _interopRequireWildcard(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _settings = _interopRequireDefault(require("./settings"));
+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 base responsável pelo gerênciamento RUNTIME da aplicação
+ * controle de cache, uso de memoria e gerênciamento de dados locais
+ *
+ * Todas as classes devem herdar esta classe para um gerênciamento completo
+ *
+ * @abstract
+ * @class Core
+ */
+class Core {
+  static settings = new _settings.default();
+
+  //# System info
+  static getVersion() {
+    try {
+      const packageJson = fs.readFileSync(_path.default.resolve(__dirname, '../../package.json'), 'utf8');
+      const packageData = JSON.parse(packageJson);
+      return packageData.version;
+    } catch (error) {
+      console.error('Error reading package.json:', error);
+      return undefined;
+    }
+  }
+
+  //#Setters
+  static setSettings(settings) {
+    this.settings = settings;
+  }
+
+  //#Getters
+  static getSettings() {
+    return this.settings;
+  }
+}
+var _default = exports.default = Core;

package/lib/app/error.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HttpError = exports.ErrorHandler = void 0;
+var _contracts = require("../contracts");
+var _utils = require("../utils");
+var _managed = _interopRequireDefault(require("./classes/managed"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class ErrorHandler extends _managed.default {
+  message;
+  error;
+  caller;
+  constructor(message, error) {
+    super();
+    this.message = message;
+    this.error = error;
+    this.caller = this.getCallerClassName();
+    this.handle();
+  }
+  handle() {
+    this.register();
+  }
+  register() {
+    const message = this.caller && this.caller != 'L' ? `[${this.caller}]->${this.message}` : this.message;
+    this.log(`${message}`, 'danger');
+    (0, _utils.logger)().error(this.error);
+  }
+  getCallerClassName() {
+    const err = new Error();
+    const stackLines = err.stack?.split('\n') || [];
+    if (stackLines.length >= 4) {
+      const callerLine = stackLines[3].trim();
+      // Extraindo o nome da função/classe
+      const match = callerLine.match(/at (\w+)/);
+      if (match && match[1]) {
+        return match[1];
+      }
+    }
+    return null;
+  }
+}
+exports.ErrorHandler = ErrorHandler;
+class HttpError extends _managed.default {
+  message;
+  statusCode;
+  level;
+  data;
+  error;
+  constructor(data) {
+    super();
+    this.message = data.message;
+    this.statusCode = data.statusCode || _contracts.EHttpResponseCode.iternalErro;
+    this.level = data.level || 'error';
+    this.data = data.data;
+    this.error = data.error;
+    this.handle();
+  }
+  handle() {
+    (0, _utils.logger)().warn(this.message, this.statusCode);
+    (0, _utils.logger)().warn(this.data);
+    this.error && (0, _utils.logger)().error(this.error);
+  }
+}
+exports.HttpError = HttpError;