exodus-framework 2.0.756 → 2.0.757

package/lib/contracts/index.js

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _console = require("./console");
+Object.keys(_console).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _console[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _console[key];
+    }
+  });
+});
+var _entity = require("./entity");
+Object.keys(_entity).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _entity[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _entity[key];
+    }
+  });
+});
+var _http = require("./http");
+Object.keys(_http).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _http[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _http[key];
+    }
+  });
+});
+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 _service = require("./service");
+Object.keys(_service).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _service[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _service[key];
+    }
+  });
+});
+var _session = require("./session");
+Object.keys(_session).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _session[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _session[key];
+    }
+  });
+});
+var _settings = require("./settings");
+Object.keys(_settings).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _settings[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _settings[key];
+    }
+  });
+});
+var _singleton = require("./singleton");
+Object.keys(_singleton).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _singleton[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _singleton[key];
+    }
+  });
+});
+var _socket = require("./socket");
+Object.keys(_socket).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _socket[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _socket[key];
+    }
+  });
+});

package/lib/contracts/messaging.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EMessagingQueue = void 0;
+let EMessagingQueue = exports.EMessagingQueue = /*#__PURE__*/function (EMessagingQueue) {
+  EMessagingQueue["test"] = "exodus.queue.test";
+  EMessagingQueue["accountCreated"] = "exodus.account.created";
+  EMessagingQueue["environmentSync"] = "exodus.environment.sync";
+  EMessagingQueue["environmentCreated"] = "exodus.environment.created";
+  EMessagingQueue["environmentDeleted"] = "exodus.environment.deleted";
+  EMessagingQueue["environmentUpdatedToken"] = "exodus.environment.updated.token";
+  EMessagingQueue["environmentUpdatedDatabase"] = "exodus.environment.updated.database";
+  EMessagingQueue["databaseSync"] = "exodus.database.sync";
+  EMessagingQueue["databaseCreated"] = "exodus.database.created";
+  EMessagingQueue["databaseUpdate"] = "exodus.database.updated";
+  EMessagingQueue["databaseDeleted"] = "exodus.database.deleted";
+  EMessagingQueue["applicationSync"] = "exodus.application.sync";
+  EMessagingQueue["applicationCreated"] = "exodus.application.created";
+  EMessagingQueue["applicationUpdate"] = "exodus.application.updated";
+  EMessagingQueue["applicationDeleted"] = "exodus.application.deleted";
+  EMessagingQueue["smsSend"] = "exodus.sms.send";
+  return EMessagingQueue;
+}({}); // Mapeamento de tópicos para tipos

package/lib/contracts/security.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/contracts/service.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/contracts/session.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/contracts/settings.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/contracts/singleton.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/contracts/socket.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ESocketEvent = void 0;
+let ESocketEvent = exports.ESocketEvent = /*#__PURE__*/function (ESocketEvent) {
+  ESocketEvent["test"] = "exodus.socket.event.test";
+  ESocketEvent["test2"] = "exodus.socket.event.test2";
+  return ESocketEvent;
+}({}); // Mapeamento de tópicos para tipos

package/lib/controllers/api/file.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _controller = _interopRequireDefault(require("../../app/controller"));
+require("express-async-errors");
+var _http = require("../../contracts/http");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// !Tratamento de erros asyncronos
+
+class FileController extends _controller.default {
+  upload = async (req, res) => {
+    this.send({
+      message: 'Salvo com sucesso',
+      type: 'success',
+      status: true,
+      data: req.file.filename,
+      code: _http.EHttpResponseCode.created
+    }, res);
+  };
+}
+var _default = exports.default = FileController;

package/lib/controllers/api/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "FileController", {
+  enumerable: true,
+  get: function () {
+    return _file.default;
+  }
+});
+var _file = _interopRequireDefault(require("./file"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/controllers/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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/controllers/messaging/application.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _app = require("../../app");
+var _models = require("../../models");
+var _utils = require("../../utils");
+class ApplicationController extends _app.MessagingController {
+  created = async (data, ack) => {
+    try {
+      await _models.Application.create(data);
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro ao tentar criar a aplicação', error);
+    } finally {
+      ack();
+    }
+  };
+  update = async (data, ack) => {
+    try {
+      const app = await _models.Application.findByPk(data.uuid);
+      if (!app) throw new Error('Aplicação não encontrada: ' + data.uuid);
+      await app.update(data.updated);
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro ao tentar atualizar a aplicação, check o log...', error);
+    } finally {
+      ack();
+    }
+  };
+  delete = async (data, ack) => {
+    try {
+      const app = await _models.Application.findByPk(data.uuid);
+      if (!app) throw new Error('Aplicação não encontrada: ' + data.uuid);
+      await app.destroy();
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro ao tentar excluír a aplicação', error);
+    } finally {
+      ack();
+    }
+  };
+  sync = async (data, ack) => {
+    try {
+      data.forEach(async app => {
+        try {
+          const host = await _models.Application.findByPk(app.uuid);
+          if (!host) {
+            (0, _utils.logger)().info(app, `Sincronizando nova integração do banco de dados ${app.name}`);
+            this.log(`Sincronizando nova integração do banco de dados ${app.name}`, 'info');
+            await _models.Application.create(app);
+          }
+        } catch (error) {
+          new _app.ErrorHandler('Houve um erro ao tentar sincronizar uma integração', error);
+        }
+      });
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro ao tentar sincronizar uma integração', error);
+    } finally {
+      ack();
+    }
+  };
+}
+var _default = exports.default = ApplicationController;

package/lib/controllers/messaging/database.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _app = require("../../app");
+var _models = require("../../models");
+var _utils = require("../../utils");
+class DatabaseController extends _app.MessagingController {
+  created = async (data, ack) => {
+    try {
+      await _models.DatabaseHost.create(data);
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro ao tentar criar um banco de dados', error);
+    } finally {
+      ack();
+    }
+  };
+  update = async (data, ack) => {
+    try {
+      const host = await _models.DatabaseHost.findByPk(data.uuid);
+      if (!host) throw new Error('Banco de dados não encontrado');
+      await host.update(data.updated);
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro ao tentar atualizar um banco de dados', error);
+    } finally {
+      ack();
+    }
+  };
+  delete = async (data, ack) => {
+    try {
+      const host = await _models.DatabaseHost.findByPk(data.uuid);
+      if (!host) throw new Error('Banco de dados não encontrado');
+      await host.destroy();
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro ao tentar excluír um banco de dados', error);
+    } finally {
+      ack();
+    }
+  };
+  sync = async (data, ack) => {
+    try {
+      data.forEach(async database => {
+        try {
+          const host = await _models.DatabaseHost.findByPk(database.uuid);
+          if (!host) {
+            (0, _utils.logger)().info(database, `Sincronizando novo host ${database.host}`);
+            this.log(`Sincronizando novo host ${database.host}`, 'info');
+            await _models.DatabaseHost.create(database);
+          }
+        } catch (error) {
+          new _app.ErrorHandler('Houve um erro ao tentar sincronizar um novo host', error);
+        }
+      });
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro ao tentar sincronizar um novo host', error);
+    } finally {
+      ack();
+    }
+  };
+}
+var _default = exports.default = DatabaseController;

package/lib/controllers/messaging/environment.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _app = require("../../app");
+var _models = require("../../models");
+var _services = require("../../services");
+var _utils = require("../../utils");
+class EnvironmentController extends _app.MessagingController {
+  created = async (data, ack) => {
+    try {
+      const db = data.database;
+      const token = data.envToken;
+      await _services.SequelizeService.singleton().createDB(db, token);
+      await _models.EnvDBHost.create({
+        envUuid: data.uuid,
+        hostUuid: data.database,
+        envToken: data.envToken
+      });
+      this.log(`New database created successfully: ${db}`);
+    } catch (error) {
+      new _app.ErrorHandler('Erro ao criar o novo banco de dados', error);
+    } finally {
+      ack();
+    }
+  };
+  deleted = async (data, ack) => {
+    try {
+      const token = data.token;
+      const db = data.database;
+      await _services.SequelizeService.singleton().deleteDB(db, token);
+      const relation = await _models.EnvDBHost.findOne({
+        where: {
+          envUuid: data.uuid
+        }
+      });
+      if (!relation) throw new Error('relação env-db não encontrada');
+      await relation.destroy();
+      this.log(`Database deleted successfully: ${token}`);
+    } catch (error) {
+      new _app.ErrorHandler('Erro ao deletar a relação env-db', error);
+    } finally {
+      ack();
+    }
+  };
+  updatedDatabase = async (data, ack) => {
+    try {
+      const relation = await _models.EnvDBHost.findOne({
+        where: {
+          envUuid: data.envUuid
+        }
+      });
+      if (!relation) throw new Error('relação env-db não encontrada');
+      await relation.update({
+        hostUuid: data.database
+      });
+      this.log(`A relação para o ambiente ${data.envUuid} foi atualizada, a migração deverá ser realizada de forma manual`);
+    } catch (error) {
+      new _app.ErrorHandler('Erro ao atualizar a relação EDB', error);
+    } finally {
+      ack();
+    }
+  };
+  sync = async (data, ack) => {
+    try {
+      data.forEach(async env => {
+        try {
+          const host = await _models.EnvDBHost.findOne({
+            where: {
+              envUuid: env.uuid
+            }
+          });
+          if (!host) {
+            (0, _utils.logger)().info(env, `Sincronizando relação env-db ${env.uuid}`);
+            this.log(`Sincronizando relação env-db ${env.uuid}`, 'info');
+            await _models.EnvDBHost.create({
+              envUuid: env.uuid,
+              hostUuid: env.database,
+              envToken: env.envToken
+            });
+          }
+          if (!(await _services.SequelizeService.singleton().hasDB(env.database, env.envToken))) {
+            (0, _utils.logger)().info(env, `Sincronizando novo banco de dados ${env.uuid}`);
+            this.log(`Sincronizando novo banco de dados ${env.uuid}`, 'info');
+            await _services.SequelizeService.singleton().createDB(env.database, env.envToken);
+          }
+        } catch (error) {
+          new _app.ErrorHandler('Houve um erro ao tentar sincronizar um novo ambiente/relação ou banco de dados', error);
+        }
+      });
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro ao tentar sincronizar um novo ambiente/relação ou banco de dados', error);
+    } finally {
+      ack();
+    }
+  };
+}
+var _default = exports.default = EnvironmentController;

package/lib/express.d.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/index.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+var _app = require("./app");
+Object.keys(_app).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _app[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _app[key];
+    }
+  });
+});
+var _contracts = require("./contracts");
+Object.keys(_contracts).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _contracts[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _contracts[key];
+    }
+  });
+});
+var _controllers = require("./controllers");
+Object.keys(_controllers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _controllers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _controllers[key];
+    }
+  });
+});
+var _middlewares = require("./middlewares");
+Object.keys(_middlewares).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _middlewares[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _middlewares[key];
+    }
+  });
+});
+var _models = require("./models");
+Object.keys(_models).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _models[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _models[key];
+    }
+  });
+});
+var _services = require("./services");
+Object.keys(_services).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _services[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _services[key];
+    }
+  });
+});
+var _utils = require("./utils");
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utils[key];
+    }
+  });
+});
+var _default = exports.default = _app.Exodus;

package/lib/middlewares/access.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dateFns = require("date-fns");
+var _app = require("../app");
+var _controller = _interopRequireDefault(require("../app/controller"));
+var _http = require("../contracts/http");
+var _models = require("../models");
+var _security = _interopRequireDefault(require("../services/security"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class AccessMiddleware extends _controller.default {
+  accessLevel = level => {
+    return (req, res, next) => {
+      if (!level.includes(req.auth.account.type)) {
+        throw new _app.HttpError({
+          message: 'Nível de acesso não permitido para esta rota.',
+          statusCode: _http.EHttpResponseCode.informationBlocked
+        });
+      }
+      next();
+    };
+  };
+  getTenant = async (req, res, next) => {
+    const account = req.auth?.account;
+    const tenantId = req.header('X-Exodus-Tenant-ID');
+    const applicationId = req.header('X-Exodus-Application-ID');
+    let envUuid = '';
+
+    /* Aplicações */
+    if (applicationId) {
+      const application = await _models.Application.findOne({
+        where: {
+          token: applicationId
+        }
+      });
+      if (!application) {
+        throw new _app.HttpError({
+          message: 'Token de aplicação inválido',
+          statusCode: _http.EHttpResponseCode.informationUnauthorized
+        });
+      } else if (!application.active) {
+        throw new _app.HttpError({
+          message: 'Token desativado',
+          statusCode: _http.EHttpResponseCode.informationBlocked
+        });
+      } else if ((0, _dateFns.isBefore)(application.expiresAt, new Date())) {
+        throw new _app.HttpError({
+          message: 'Token expirado',
+          statusCode: _http.EHttpResponseCode.informationBlocked
+        });
+      } else {
+        //valido
+        const data = await _security.default.singleton().verifySignature(applicationId, _security.default.singleton().getServicePublicKey());
+        if (!data) {
+          throw new _app.HttpError({
+            message: 'Token sem autênticidade.',
+            statusCode: _http.EHttpResponseCode.informationBlocked
+          });
+        }
+        envUuid = data.payload.envUuid;
+      }
+    } else if (tenantId) {
+      envUuid = tenantId;
+    }
+    if (account && account.type != 'ADMINISTRATOR') {
+      envUuid = account.envUuid;
+    }
+    req.tenant = {
+      id: envUuid || _app.Core.settings.getDatabase().service.database
+    };
+    next();
+  };
+}
+var _default = exports.default = AccessMiddleware;

package/lib/middlewares/authentication.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _expressJwt = require("express-jwt");
+var _app = require("../app");
+var _controller = _interopRequireDefault(require("../app/controller"));
+var _security = _interopRequireDefault(require("../services/security"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class AuthenticationMiddleware extends _controller.default {
+  decryptToken = (0, _expressJwt.expressjwt)({
+    secret: async () => {
+      return _security.default.singleton().getServicePublicKey().toPEM(false);
+    },
+    issuer: _app.Core.settings.getAuthentication().serviceIssuer,
+    algorithms: ['RS256']
+  });
+}
+var _default = exports.default = AuthenticationMiddleware;