exodus-framework 2.0.699 → 2.0.701

package/lib/routes/index.js

@@ -0,0 +1,16 @@
+"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];
+    }
+  });
+});

package/lib/routes/messaging/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+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();
+
+//* Definitions
+const NativeMessagingRoutes = {
+  /* Connections Library */
+  'exodus.database.created': databaseController.created,
+  'exodus.database.updated': databaseController.update,
+  'exodus.database.deleted': databaseController.delete,
+  /* Environment Sync Database Relations */
+  'exodus.environment.created': envController.created,
+  'exodus.environment.deleted': envController.deleted,
+  'exodus.environment.updated.token': envController.updatedToken,
+  'exodus.environment.updated.database': envController.updatedDatabase
+};
+var _default = exports.default = NativeMessagingRoutes;

package/lib/services/error.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ApplicationHttpException = exports.ApplicationException = void 0;
+var _logger = _interopRequireDefault(require("../utils/logger"));
+var _http = require("../contracts/http");
+var _core = _interopRequireDefault(require("../app/core"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class ExodusErrorBase extends _core.default {
+  constructor() {
+    super();
+  }
+}
+class ApplicationHttpException extends ExodusErrorBase {
+  message;
+  statusCode;
+  level;
+  data;
+  constructor(message, statusCode = _http.EHttpResponseCode.iternalErro, level = 'error', data) {
+    super();
+    this.message = message;
+    this.statusCode = statusCode;
+    this.level = level;
+    this.data = data;
+    this.handle();
+  }
+  handle() {
+    (0, _logger.default)().warn(this.message, this.statusCode);
+    (0, _logger.default)().warn(this.data);
+  }
+}
+exports.ApplicationHttpException = ApplicationHttpException;
+class ApplicationException extends ExodusErrorBase {
+  message;
+  error;
+  constructor(message, error) {
+    super();
+    this.message = message;
+    this.error = error;
+    this.handle();
+  }
+  handle() {
+    this.log(`${this.message}`, 'danger');
+    (0, _logger.default)().error(this.error);
+  }
+}
+exports.ApplicationException = ApplicationException;

package/lib/services/express.js

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _service = _interopRequireDefault(require("../app/service"));
+var _logger = _interopRequireDefault(require("../utils/logger"));
+var _cors = _interopRequireDefault(require("cors"));
+var _express = _interopRequireDefault(require("express"));
+require("express-async-errors");
+var http = _interopRequireWildcard(require("http"));
+var _pinoHttp = _interopRequireDefault(require("pino-http"));
+var _http2 = require("../contracts/http");
+var _error = require("./error");
+var _app = require("../app");
+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 }; }
+class ExpressService extends _service.default {
+  server;
+  mainRouter;
+  async init() {
+    if (!this.mainRouter) throw new _error.ApplicationException('Need router'); //!sem router
+
+    const expss = (0, _express.default)();
+    const pino = (0, _pinoHttp.default)({
+      logger: (0, _logger.default)()
+    });
+    this.server = http.createServer(expss);
+    expss.use('/public', _express.default.static(_app.Core.settings.getHttp().publicPath));
+    expss.use(pino);
+    expss.use(this.responseTypeMiddleware.bind(this));
+    expss.use(_express.default.json());
+    expss.use(_express.default.urlencoded({
+      extended: false
+    }));
+    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));
+    this.server.listen(_app.Core.settings.getAppication().port, () => {
+      (0, _logger.default)().info(`servidor iniciado na porta: ${_app.Core.settings.getAppication().port}`);
+      this.log(`🌍 Http Server Listering On: ${_app.Core.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 (_app.Core.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();
+  }
+
+  //* Handlers
+  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.ApplicationHttpException('Falha na autorização', _http2.EHttpResponseCode.informationUnauthorized);
+    } else {
+      next(err);
+    }
+  }
+  handleRequestProcessFailure = async (err, req, res, _) => {
+    if (err instanceof _error.ApplicationHttpException) {
+      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.ApplicationException('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.ApplicationHttpException('Requisição incompleta', _http2.EHttpResponseCode.incompleteRequest, 'error', {
+      need
+    });
+  }
+  registerRouter(router) {
+    this.mainRouter = router;
+  }
+}
+var _default = exports.default = ExpressService;

package/lib/services/file.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _service = _interopRequireDefault(require("../app/service"));
+var _logger = _interopRequireDefault(require("../utils/logger"));
+var fs = _interopRequireWildcard(require("fs"));
+var fsPromisses = _interopRequireWildcard(require("fs/promises"));
+var _app = require("../app");
+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 }; }
+class FileService extends _service.default {
+  async init() {
+    await this.checkPaths();
+    await this.cleanTemp();
+  }
+  async checkPaths() {
+    for (const path of Object.values(_app.Core.settings.getAppication().filePaths)) {
+      !fs.existsSync(path) && fs.mkdirSync(path, {
+        recursive: true
+      });
+    }
+  }
+  async cleanTemp() {
+    this.listFiles('temporary', files => {
+      files.forEach(file => {
+        const p = _app.Core.settings.getAppication().filePaths.temporary + '/' + file;
+        fs.rmSync(p, {
+          recursive: true
+        });
+      });
+    });
+  }
+  async save(filename, destiny) {
+    const p = _app.Core.settings.getAppication().filePaths.temporary + '/' + filename;
+    const d = _app.Core.settings.getAppication().filePaths[destiny] + '/' + filename;
+    return await fsPromisses.rename(p, d).then(() => d).catch(e => {
+      (0, _logger.default)().error({
+        filename,
+        destiny,
+        erro: e
+      }, 'Não foi possível salvar o arquivo');
+      return false;
+    });
+  }
+  async delete(filename, destiny) {
+    const d = _app.Core.settings.getAppication().filePaths[destiny] + '/' + filename;
+    return await fsPromisses.unlink(d).then(() => true).catch(e => {
+      (0, _logger.default)().error({
+        filename,
+        destiny,
+        erro: e
+      }, 'Não foi possível deletar o arquivo');
+      return false;
+    });
+  }
+  listFiles(origin, cb) {
+    const p = _app.Core.settings.getAppication().filePaths[origin];
+    fs.readdir(p, (_, file) => cb(file));
+  }
+}
+var _default = exports.default = FileService;

package/lib/services/index.d.ts

@@ -5,5 +5,6 @@ export { default as RabbitMQService } from './rabitmq';
 export { default as RedisService } from './redis';
 export { default as SequelizeService } from './sequelize';
 export { default as SocketIOService } from './socket';
+export { default as SecurityService } from './security';
 export * from './task';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,QAAQ,CAAC;AAChD,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,WAAW,CAAC;AACvD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,UAAU,CAAC;AACtD,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,QAAQ,CAAC;AAChD,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,WAAW,CAAC;AACvD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,YAAY,CAAC;AACxD,cAAc,QAAQ,CAAC"}

package/lib/services/index.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  ExpressService: true,
+  FileService: true,
+  RabbitMQService: true,
+  RedisService: true,
+  SequelizeService: true,
+  SocketIOService: true,
+  SecurityService: true
+};
+Object.defineProperty(exports, "ExpressService", {
+  enumerable: true,
+  get: function () {
+    return _express.default;
+  }
+});
+Object.defineProperty(exports, "FileService", {
+  enumerable: true,
+  get: function () {
+    return _file.default;
+  }
+});
+Object.defineProperty(exports, "RabbitMQService", {
+  enumerable: true,
+  get: function () {
+    return _rabitmq.default;
+  }
+});
+Object.defineProperty(exports, "RedisService", {
+  enumerable: true,
+  get: function () {
+    return _redis.default;
+  }
+});
+Object.defineProperty(exports, "SecurityService", {
+  enumerable: true,
+  get: function () {
+    return _security.default;
+  }
+});
+Object.defineProperty(exports, "SequelizeService", {
+  enumerable: true,
+  get: function () {
+    return _sequelize.default;
+  }
+});
+Object.defineProperty(exports, "SocketIOService", {
+  enumerable: true,
+  get: function () {
+    return _socket.default;
+  }
+});
+var _error = require("./error");
+Object.keys(_error).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _error[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _error[key];
+    }
+  });
+});
+var _express = _interopRequireDefault(require("./express"));
+var _file = _interopRequireDefault(require("./file"));
+var _rabitmq = _interopRequireDefault(require("./rabitmq"));
+var _redis = _interopRequireDefault(require("./redis"));
+var _sequelize = _interopRequireDefault(require("./sequelize"));
+var _socket = _interopRequireDefault(require("./socket"));
+var _security = _interopRequireDefault(require("./security"));
+var _task = require("./task");
+Object.keys(_task).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _task[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _task[key];
+    }
+  });
+});
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/services/rabitmq.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _service = _interopRequireDefault(require("../app/service"));
+var _amqplib = _interopRequireDefault(require("amqplib"));
+var _error = require("./error");
+var _app = require("../app");
+var _messaging = _interopRequireDefault(require("../routes/messaging"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Serviço de Mensageria
+ *
+ * @class RabbitMQService
+ * @extends {Service}
+ * @implements {IService}
+ */
+class RabbitMQService extends _service.default {
+  connection;
+  channel;
+  connected;
+  mainRouter;
+
+  //# Initialization
+  constructor() {
+    super();
+  }
+  async init() {
+    if (!this.mainRouter) throw new _error.ApplicationException('Need router'); //!sem router
+
+    this.mainRouter = {
+      ...this.mainRouter,
+      ..._messaging.default
+    }; // # Register native router
+    await this.connect();
+  }
+  registerHandles() {
+    for (const [queue, handle] of Object.entries(this.mainRouter)) {
+      this.consumeFromQueue(queue, handle);
+    }
+  }
+  async connect() {
+    if (this.connected && this.channel) return;else this.connected = true;
+    try {
+      this.log(`⌛️ Connecting to Rabbit-MQ Server`);
+      this.connection = await _amqplib.default.connect(`amqp://${_app.Core.settings.getMessaging().user}:${_app.Core.settings.getMessaging().pass}@${_app.Core.settings.getMessaging().host}:5672`);
+      this.log(`✅ Rabbit MQ Connection is ready`);
+      this.channel = await this.connection.createChannel();
+      this.log(`🛸 Created RabbitMQ Channel successfully`);
+      this.registerHandles();
+    } catch (error) {
+      new _error.ApplicationException(`Not connected to MQ Server`, error);
+    }
+  }
+
+  //# Common
+  async sendToQueue(queue, data) {
+    try {
+      if (!this.channel) {
+        await this.connect();
+      }
+      this.channel.sendToQueue(queue, Buffer.from(JSON.stringify(data)));
+    } catch (error) {
+      new _error.ApplicationException('Houve um erro no envio de uma mensagem para o rabitmq', error);
+    }
+  }
+  async consumeFromQueue(queue, callBack) {
+    await this.channel.assertQueue(queue, {
+      durable: true
+    });
+    this.channel.consume(queue, msg => {
+      {
+        if (!msg) {
+          return this.log(`Invalid incoming message in`);
+        }
+        try {
+          callBack(JSON.parse(msg.content.toString()), () => this.channel.ack(msg));
+        } catch (error) {
+          this.channel.ack(msg);
+          new _error.ApplicationException('Error on parsing message from queue', error);
+        }
+      }
+    }, {
+      noAck: false
+    });
+  }
+  registerRouter(router) {
+    this.mainRouter = router;
+  }
+}
+var _default = exports.default = RabbitMQService;

package/lib/services/redis.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _service = _interopRequireDefault(require("../app/service"));
+var _redis = require("redis");
+var _error = require("./error");
+var _app = require("../app");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Serviço de cache
+ *
+ * @class RedisService
+ * @extends {Service}
+ * @implements {IService}
+ */
+class RedisService extends _service.default {
+  client;
+
+  //* Initialization
+  async init() {
+    this.client = (0, _redis.createClient)({
+      url: `redis://${_app.Core.settings.getCache().host}:${_app.Core.settings.getCache().port}`,
+      password: _app.Core.settings.getCache().password
+    });
+    await this.connect();
+  }
+  connect() {
+    this.client.on('error', this.onClientError.bind(this));
+    return new Promise(resolve => {
+      this.client.connect().then(() => {
+        this.log('Redis client connected.', 'success');
+        resolve(true);
+      });
+    });
+  }
+  async disconnect() {
+    await this.client.quit();
+  }
+
+  //* Common
+  async setValue(key, value) {
+    await this.client.set(key, value);
+  }
+  async getValue(key) {
+    const value = await this.client.get(key);
+    return value;
+  }
+  async deleteValue(key) {
+    await this.client.del(key);
+  }
+
+  //* Events
+  onClientError(err) {
+    new _error.ApplicationException('Error on init redis client', err);
+  }
+}
+var _default = exports.default = RedisService;