exodus-framework 2.0.955 → 2.0.958

package/lib/models/index.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  NativeModels: true
+};
+exports.NativeModels = void 0;
+var _Log = require("./Log");
+Object.keys(_Log).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Log[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Log[key];
+    }
+  });
+});
+var _System = require("./System");
+Object.keys(_System).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _System[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _System[key];
+    }
+  });
+});
+var _Report = require("./Report");
+Object.keys(_Report).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Report[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Report[key];
+    }
+  });
+});
+var _Application = require("./Application");
+Object.keys(_Application).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Application[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Application[key];
+    }
+  });
+});
+var _DatabaseHost = require("./DatabaseHost");
+Object.keys(_DatabaseHost).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _DatabaseHost[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _DatabaseHost[key];
+    }
+  });
+});
+var _EnvConnection = require("./EnvConnection");
+Object.keys(_EnvConnection).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _EnvConnection[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _EnvConnection[key];
+    }
+  });
+});
+const NativeModels = exports.NativeModels = [_Log.Log, _System.System, _Report.Report];

package/lib/routes/api/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _v = require("./v1");
+Object.keys(_v).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _v[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _v[key];
+    }
+  });
+});

package/lib/routes/api/v1/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _logs = require("./logs");
+Object.keys(_logs).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _logs[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _logs[key];
+    }
+  });
+});
+var _report = require("./report");
+Object.keys(_report).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _report[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _report[key];
+    }
+  });
+});
+var _sse = require("./sse");
+Object.keys(_sse).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _sse[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _sse[key];
+    }
+  });
+});

package/lib/routes/api/v1/logs.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logRouter = void 0;
+var _express = require("express");
+var _log = _interopRequireDefault(require("../../../controllers/api/log"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//* Router
+const logRouter = exports.logRouter = (0, _express.Router)();
+
+//* Middlewares
+
+//* Controllers
+const logController = new _log.default();
+
+//* Definitions
+logRouter.route('/list').post(logController.list);

package/lib/routes/api/v1/report.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.reportRouter = void 0;
+var _express = require("express");
+var _report = _interopRequireDefault(require("../../../controllers/api/report"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//* Router
+const reportRouter = exports.reportRouter = (0, _express.Router)();
+
+//* Middlewares
+
+//* Controllers
+const reportController = new _report.default();
+
+//* Definitions
+reportRouter.route('/list').post(reportController.list);

package/lib/routes/api/v1/sse.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sseRouter = void 0;
+var _express = require("express");
+const sseRouter = exports.sseRouter = (0, _express.Router)();
+sseRouter.route('/sse').post((req, res) => {
+  // Definir cabeçalhos SSE
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  res.flushHeaders(); // Enviar headers imediatamente
+
+  // Função para enviar eventos
+  const sendEvent = data => {
+    res.write(`data: ${data}\n\n`); // Formatação para SSE
+  };
+
+  // Enviar um evento inicial
+  sendEvent('Conexão SSE estabelecida!');
+
+  // Exemplo: enviar eventos periodicamente
+  const intervalId = setInterval(() => {
+    const message = `Mensagem do servidor: ${new Date().toLocaleTimeString()}`;
+    sendEvent(message);
+  }, 5000);
+
+  // Limpar intervalo e encerrar conexão quando o cliente fechar a conexão
+  req.on('close', () => {
+    clearInterval(intervalId);
+    res.end();
+    console.log('Conexão SSE fechada.');
+  });
+});

package/lib/routes/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _messaging = require("./messaging");
+Object.keys(_messaging).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _messaging[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _messaging[key];
+    }
+  });
+});
+var _api = require("./api");
+Object.keys(_api).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _api[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _api[key];
+    }
+  });
+});

package/lib/routes/messaging/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _application = _interopRequireDefault(require("../../controllers/messaging/application"));
+var _database = _interopRequireDefault(require("../../controllers/messaging/database"));
+var _environment = _interopRequireDefault(require("../../controllers/messaging/environment"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//* Controllers
+const databaseController = new _database.default();
+const envController = new _environment.default();
+const appController = new _application.default();
+
+//* Definitions
+const NativeMessagingRoutes = {
+  /* Connections Library */
+  'exodus.database.created': databaseController.created,
+  'exodus.database.updated': databaseController.update,
+  'exodus.database.deleted': databaseController.delete,
+  'exodus.database.sync': databaseController.sync,
+  /* Application Integrations */
+  'exodus.application.created': appController.created,
+  'exodus.application.updated': appController.update,
+  'exodus.application.deleted': appController.delete,
+  'exodus.application.sync': appController.sync,
+  /* Environment Sync Database Relations */
+  'exodus.environment.created': envController.created,
+  'exodus.environment.deleted': envController.deleted,
+  'exodus.environment.sync': envController.sync,
+  'exodus.environment.updated.database': envController.updatedDatabase
+};
+var _default = exports.default = NativeMessagingRoutes;

package/lib/services/database.d.ts

@@ -11,6 +11,13 @@ declare class DatabaseService extends Service {
     private initConnection;
     createConnection(host: string, port: number, database: string, username: string, password: string, dialect: Dialect): Promise<Sequelize>;
     getConnection(tenantId: string): Promise<Sequelize>;
+    testConnection(data: {
+        host: string;
+        port: number;
+        username: string;
+        password: string;
+        dialect: Dialect;
+    }): Promise<boolean>;
     getTenantIds(): Promise<string[]>;
     getTenantInformation(tenantId: string): Promise<EnvDBHost>;
     private loadEntity;

package/lib/services/database.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../src/services/database.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACnE,OAAO,EAAsB,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAgB,SAAS,EAAE,MAAM,WAAW,CAAC;AAIpD,cAAM,eAAgB,SAAQ,OAAO;IACnC,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,WAAW,CAAyB;IAE/B,aAAa;IAWb,OAAO;IAgBP,WAAW;YAMV,cAAc;IA0Cf,gBAAgB,CAC3B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO;IAwBL,aAAa,CAAC,QAAQ,EAAE,MAAM;IAQ9B,YAAY;IAKZ,oBAAoB,CAAC,QAAQ,EAAE,MAAM;YAMpC,UAAU;IASX,SAAS,CAAC,CAAC,SAAS,YAAY,CAAC,KAAK,CAAC,EAClD,KAAK,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC5B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAU1B,OAAO,CAAC,qBAAqB;CAG9B;AAED,eAAe,eAAe,CAAC"}
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../src/services/database.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACnE,OAAO,EAAsB,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAgB,SAAS,EAAE,MAAM,WAAW,CAAC;AAIpD,cAAM,eAAgB,SAAQ,OAAO;IACnC,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,WAAW,CAAyB;IAE/B,aAAa;IAWb,OAAO;IAgBP,WAAW;YAMV,cAAc;IA0Cf,gBAAgB,CAC3B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO;IAwBL,aAAa,CAAC,QAAQ,EAAE,MAAM;IAO9B,cAAc,CAAC,IAAI,EAAE;QAChC,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,OAAO,CAAC;KAClB;IA4BY,YAAY;IAKZ,oBAAoB,CAAC,QAAQ,EAAE,MAAM;YAMpC,UAAU;IASX,SAAS,CAAC,CAAC,SAAS,YAAY,CAAC,KAAK,CAAC,EAClD,KAAK,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC5B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAU1B,OAAO,CAAC,qBAAqB;CAG9B;AAED,eAAe,eAAe,CAAC"}

package/lib/services/database.js

@@ -0,0 +1,158 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _sequelize = require("sequelize");
+var _app = require("../app");
+var _models = require("../models");
+var _utils = require("../utils");
+var _security = _interopRequireDefault(require("./security"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class DatabaseService extends _app.Service {
+  entities;
+  connections;
+  async onServiceInit() {
+    this.entities = new Map();
+    this.connections = new Map();
+
+    // para busca rápidas
+    this.connections.set(_app.Core.settings.getDatabase().main.database, _utils.mainDb);
+    this.startAttemptDelay = 5 * 1000;
+    this.maxStartAttempts = 3;
+  }
+  async onStart() {
+    this.log(`⌛️ Connecting Sequelize to database: ${this.currentStartAttempts}/${this.maxStartAttempts}`);
+    try {
+      await _utils.mainDb.authenticate();
+      await _utils.mainDb.sync({
+        alter: true
+      });
+      this.log('✅ Connected service database sucessfully', 'success');
+      return true;
+    } catch (error) {
+      (0, _utils.logger)().error(error, `Not connected Sequelize to database`);
+      return false;
+    }
+  }
+  async onStartFail() {
+    await super.onStartFail();
+    this.log(`Not possible to connect database`, 'danger');
+  }
+
+  //* Connection
+  async initConnection(tenantId) {
+    const tenantInfo = await this.getTenantInformation(tenantId);
+    if (!tenantInfo) {
+      throw new Error(`Não é possível inicia a conexão para o tenant ${tenantId}, a relação EnvDB não foi localizada`);
+    }
+    const dbHost = await _models.DatabaseHost.findByPk(tenantInfo.hostUuid);
+    if (!tenantInfo) {
+      throw new Error(`Não é possível inicia a conexão para o tenant ${tenantId}, não foi possível localizar a informação de host`);
+    }
+    const splitedInfo = dbHost.host.split(':');
+    const address = splitedInfo[0];
+    const port = Number(splitedInfo[1]);
+    const database = this.normalizeDatabaseName(tenantInfo.envToken);
+    const key = await _security.default.getService().loadKeyByStr(dbHost.credential);
+    const data = await _security.default.getService().verifySignature(dbHost.password, key);
+    if (!data) {
+      throw new Error(`Não foi possível descriptografar as credenciais de conexão para hostUuid: ${tenantInfo.hostUuid}`);
+    }
+    const password = data.payload;
+    const connection = await this.createConnection(address, port, database, dbHost.username, password, dbHost.dialect);
+    this.connections.set(tenantId, connection);
+  }
+  async createConnection(host, port, database, username, password, dialect) {
+    const sequelize = new _sequelize.Sequelize({
+      host,
+      port,
+      dialect,
+      database,
+      username,
+      password,
+      define: {
+        timestamps: true
+      },
+      timezone: '-03:00',
+      logging: _app.Core.settings.getDatabase().service.log,
+      pool: _app.Core.settings.getDatabase().service.pool
+    });
+    try {
+      await sequelize.authenticate();
+      return sequelize;
+    } catch (error) {
+      new _app.ErrorHandler('Não foi possível realizar uma conexão', error);
+      return null;
+    }
+  }
+  async getConnection(tenantId) {
+    if (!this.connections.has(tenantId)) {
+      await this.initConnection(tenantId);
+    }
+    return this.connections.get(tenantId);
+  }
+  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();
+      });
+    });
+  }
+
+  //* Environment
+  async getTenantIds() {
+    const tenants = await _models.EnvDBHost.findAll({
+      attributes: ['envUuid']
+    });
+    return tenants.map(t => t.envUuid);
+  }
+  async getTenantInformation(tenantId) {
+    const relation = await _models.EnvDBHost.findOne({
+      where: {
+        envUuid: tenantId
+      }
+    });
+    return relation;
+  }
+
+  //* Entity
+  async loadEntity(entity, tenantId) {
+    const k = `${tenantId}#${entity.name}`;
+    const connection = await this.getConnection(tenantId);
+    const loadedEntity = entity.initialize(connection);
+    await loadedEntity.sync({
+      alter: true
+    });
+    this.entities.set(k, loadedEntity);
+  }
+  async getEntity(model, tenantId) {
+    const k = `${tenantId}#${model.name}`;
+    if (!this.entities.has(k)) {
+      await this.loadEntity(model, tenantId);
+    }
+    return this.entities.get(k);
+  }
+
+  //* Utils
+  normalizeDatabaseName(envToken) {
+    return `${_app.Core.settings.getDatabase().main.database}_${envToken}`;
+  }
+}
+var _default = exports.default = DatabaseService;

package/lib/services/ecosystem.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _app = require("../app");
+var _System = require("../models/System");
+var _sequelize = _interopRequireDefault(require("./sequelize"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class EcosystemService extends _app.Service {
+  async getSystemVariable(tenantId, key) {
+    const Entity = await _sequelize.default.singleton().getModel(_System.System, tenantId);
+    return Entity.findOne({
+      where: {
+        key
+      }
+    });
+  }
+  async setSystemVariable(tenantId, key, value) {
+    const Entity = await _sequelize.default.singleton().getModel(_System.System, tenantId);
+    const variable = await Entity.findOne({
+      where: {
+        key
+      }
+    });
+    if (!variable) throw new Error('System variable not found: ' + key);
+    variable.value = value;
+    variable.changed('value', true);
+    await variable.save();
+  }
+  async createSystemVariable(tenantId, key, value) {
+    const Entity = await _sequelize.default.singleton().getModel(_System.System, tenantId);
+    const variable = await Entity.findOne({
+      where: {
+        key
+      }
+    });
+    if (variable) throw new Error('System variable has exists: ' + key);
+    return await Entity.create({
+      key,
+      value
+    });
+  }
+}
+var _default = exports.default = EcosystemService;

package/lib/services/express.js

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _cors = _interopRequireDefault(require("cors"));
+var _express = _interopRequireDefault(require("express"));
+var _expressRequestsLogger = _interopRequireDefault(require("express-requests-logger"));
+var http = _interopRequireWildcard(require("http"));
+var _qs = _interopRequireDefault(require("qs"));
+var _core = _interopRequireDefault(require("../app/core"));
+var _error = require("../app/error");
+var _service = _interopRequireDefault(require("../app/classes/service"));
+var _http2 = require("../contracts/http");
+var _logger = _interopRequireDefault(require("../utils/logger"));
+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; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// import 'express-async-errors';
+
+class ExpressService extends _service.default {
+  server;
+  mainRouter;
+
+  //!Deve ser iniciado no cluster, pois no master causa erro de port bind
+  async onServiceClusterInit() {
+    await super.onServiceClusterInit();
+    if (!this.mainRouter) throw new Error('Need router'); //!sem router
+  }
+  async onStartCluster() {
+    await super.onStartCluster();
+    const expss = (0, _express.default)();
+    this.server = http.createServer(expss);
+    expss.use('/public', _express.default.static(_core.default.settings.getHttp().publicPath));
+    expss.use((0, _expressRequestsLogger.default)({
+      logger: (0, _logger.default)()
+    }));
+    expss.set('query parser', str => _qs.default.parse(str));
+    expss.use(this.responseTypeMiddleware.bind(this));
+    expss.use(_express.default.json({
+      limit: '10mb'
+    }));
+    expss.use(_express.default.urlencoded({
+      extended: true,
+      limit: '10mb'
+    }));
+    expss.use((0, _cors.default)({
+      origin: '*'
+    }));
+    expss.use(this.mainRouter);
+    expss.use(this.handleAuthorizationFailure.bind(this));
+    expss.use(this.handleNotFoud.bind(this));
+    expss.use(this.handleRequestProcessFailure.bind(this));
+    return true;
+  }
+  async onExodusClusterStarted() {
+    await super.onExodusClusterStarted();
+    this.server.listen(_core.default.settings.getAppication().port, () => {
+      (0, _logger.default)().info(`servidor iniciado na porta: ${_core.default.settings.getAppication().port}`);
+      this.log(`🌍 Http Server Listering On: ${_core.default.settings.getAppication().port}`, 'success');
+    });
+  }
+  getHttpServer() {
+    return this.server;
+  }
+  sendResponse(objResponse, res, next) {
+    objResponse.timestamp = Date.now();
+    if (!objResponse.code) objResponse.code = _http2.EHttpResponseCode.successfullyProcessedInformation;
+    res.status(objResponse.code);
+    if (objResponse.location) {
+      res.location(objResponse.location);
+      delete objResponse.location;
+    }
+    let FormulatedResponse;
+    switch (_core.default.settings.getHttp().formulation) {
+      case 'direct':
+        if (objResponse['data']) {
+          FormulatedResponse = objResponse.data;
+        } else {
+          FormulatedResponse = objResponse;
+        }
+        break;
+      case 'standart':
+        FormulatedResponse = objResponse;
+        break;
+      default:
+        FormulatedResponse = objResponse;
+        break;
+    }
+    if (next) {
+      res.write(JSON.stringify(FormulatedResponse));
+      next();
+    } else {
+      res.send(JSON.stringify(FormulatedResponse));
+    }
+  }
+  responseTypeMiddleware(req, res, next) {
+    res.contentType('application/json');
+    next();
+  }
+
+  //* Handler errors
+  handleNotFoud(req, res) {
+    this.sendResponse({
+      message: 'Endereço não encontrado',
+      type: 'warning',
+      status: false,
+      code: _http2.EHttpResponseCode.informationNotFound
+    }, res);
+  }
+  handleAuthorizationFailure(err, req, res, next) {
+    if (err.name === 'UnauthorizedError') {
+      throw new _error.HttpError({
+        message: 'Falha na autorização',
+        statusCode: _http2.EHttpResponseCode.informationUnauthorized
+      });
+    } else {
+      next(err);
+    }
+  }
+  handleRequestProcessFailure = async (err, req, res, _) => {
+    if (err instanceof _error.HttpError) {
+      return this.sendResponse({
+        message: err.message,
+        type: err.level,
+        status: false,
+        code: err.statusCode,
+        data: err.data
+      }, res);
+    }
+    this.sendResponse({
+      message: 'Houve um erro ao acessar este recurso',
+      type: 'error',
+      status: false,
+      code: 500
+    }, res);
+    new _error.ErrorHandler('Erro não tratado em uma rota.', err);
+  };
+  async checkRequest(params) {
+    let pass = true;
+    const need = [];
+    for (const [key, param] of Object.entries(params)) {
+      if (!param || param === null || param.length < 1 || typeof param === 'string' && param === '' || typeof param === 'object' && Object.values(param).length < 1) {
+        pass = false;
+        need.push(key);
+      }
+    }
+    if (!pass) throw new _error.HttpError({
+      message: 'Requisição incompleta',
+      statusCode: _http2.EHttpResponseCode.incompleteRequest,
+      level: 'error',
+      data: {
+        need
+      }
+    });
+  }
+  static registerRouter(router) {
+    this.getService().mainRouter = router;
+  }
+}
+var _default = exports.default = ExpressService;