exodus-framework 2.0.955 → 2.0.958

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/classes/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 onStart() {
+    await Promise.all([this.checkPaths(), this.cleanTemp()]);
+    return true;
+  }
+  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 => {
+      for (const file of files) {
+        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/file_new.js

@@ -0,0 +1,136 @@
+// import { createHash } from 'crypto';
+// import * as fs from 'fs';
+// import * as fsPromisses from 'fs/promises';
+// import NodeCache from 'node-cache';
+// import { Core, ErrorHandler } from '../app';
+// import Service from '../app/classes/service';
+// import { TFilePathSettings } from '../contracts/settings';
+// import logger from '../utils/logger';
+
+// class FileService extends Service {
+//   protected cache: NodeCache;
+
+//   async onServiceInit() {
+//     this.cache = new NodeCache();
+//     await Promise.all([this.checkPaths(), this.cleanTemp()]);
+//   }
+
+//   //# Managment
+//   async save(filename: string, destiny: keyof TFilePathSettings) {
+//     const p = Core.settings.getAppication().filePaths.temporary + '/' + filename;
+//     const d = Core.settings.getAppication().filePaths[destiny] + '/' + filename;
+
+//     try {
+//       const md5 = await this.getMD5FromFile(p);
+
+//       if (this.cache.has(md5)) {
+//         return true;
+//       }
+
+//       await this.move(p, d);
+//       this.cache.set(md5, d);
+
+//       return true;
+//     } catch (error) {
+//       new ErrorHandler('Não foi possível salva o arquivo', error);
+//       return false;
+//     }
+//   }
+//   async delete(filename: string, destiny: keyof TFilePathSettings) {
+//     const d = Core.settings.getAppication().filePaths[destiny] + '/' + filename;
+//     return await fsPromisses
+//       .unlink(d)
+//       .then(() => true)
+//       .catch((e) => {
+//         logger().error({ filename, destiny, erro: e }, 'Não foi possível deletar o arquivo');
+//         return false;
+//       });
+//   }
+//   async move(to: string, from: string) {
+//     return await fsPromisses
+//       .rename(to, from)
+//       .then((d) => d)
+//       .catch((e) => {
+//         logger().error({ to, from, erro: e }, 'Não foi possível mover o arquivo');
+//         return false;
+//       });
+//   }
+
+//   //# Getters
+//   public getBuffer(filename: string, destiny: keyof TFilePathSettings) {
+//     const d = Core.settings.getAppication().filePaths[destiny] + '/' + filename;
+
+//     return new Promise((resolve, reject) => {
+//       this.getMD5FromFile(d).then();
+
+//       fsPromisses
+//         .readFile(path)
+//         .then(cb)
+//         .catch((e) => {
+//           logger.error({ path, erro: e }, 'Não foi possível ler o arquivo', path);
+//         });
+//     });
+//   }
+//   /* public getStatByMD5(filename: string, destiny: keyof TFilePathSettings) {
+//     const p = this.getPathByMD5(md5);
+//     if (!p) return;
+//     return fs.statSync(p);
+//   } */
+
+//   //# Utils
+//   private async checkPaths() {
+//     for (const path of Object.values(Core.settings.getAppication().filePaths)) {
+//       !fs.existsSync(path) && fs.mkdirSync(path, { recursive: true });
+//     }
+//   }
+//   private async cleanTemp() {
+//     this.listFiles('temporary', (files) => {
+//       for (const file of files) {
+//         const p = Core.settings.getAppication().filePaths.temporary + '/' + file;
+//         fs.rmSync(p, { recursive: true });
+//       }
+//     });
+//   }
+//   public listFiles(origin: keyof TFilePathSettings, cb: (file: string[]) => void) {
+//     const p = Core.settings.getAppication().filePaths[origin];
+//     fs.readdir(p, (_, file) => cb(file));
+//   }
+
+//   //# MD5
+//   public getMD5FromFile(filePath: string) {
+//     return new Promise<string>((resolve, reject) => {
+//       const hash = createHash('md5');
+//       const stream = fs.createReadStream(filePath);
+
+//       stream.on('data', (dados) => hash.update(dados));
+//       stream.on('error', (error) => reject(error));
+//       stream.on('end', () => resolve(hash.digest('hex')));
+//     });
+//   }
+//   public getMD5FromBuffer(buffer: Buffer) {
+//     const hash = createHash('md5');
+//     hash.update(buffer);
+//     return hash.digest('hex');
+//   }
+
+//   //# Cache
+//   public loadCache() {}
+//   public async hasCached(filePath: string) {
+//     const md5 = await this.getMD5FromFile(filePath);
+
+//     return this.cache.has(md5);
+//   }
+//   //!imcomplete
+//   /* public async loadItem(filename: string, origin: keyof TFilePathSettings) {
+//     try {
+//       const p = Core.settings.getAppication().filePaths[origin] + '/' + filename;
+//       const md5 = await this.getMD5FromFile(p);
+
+//       return md5;
+//     } catch (error) {
+//       return;
+//     }
+//   } */
+// }
+// export default FileService;
+"use strict";

package/lib/services/index.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  ExpressService: true,
+  FileService: true,
+  RabbitMQService: true,
+  RedisService: true,
+  SequelizeService: true,
+  SocketIOService: true,
+  SecurityService: true,
+  LogService: true,
+  EcosystemService: true,
+  TestService: true,
+  DatabaseService: true
+};
+Object.defineProperty(exports, "DatabaseService", {
+  enumerable: true,
+  get: function () {
+    return _database.default;
+  }
+});
+Object.defineProperty(exports, "EcosystemService", {
+  enumerable: true,
+  get: function () {
+    return _ecosystem.default;
+  }
+});
+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, "LogService", {
+  enumerable: true,
+  get: function () {
+    return _log.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;
+  }
+});
+Object.defineProperty(exports, "TestService", {
+  enumerable: true,
+  get: function () {
+    return _test.default;
+  }
+});
+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 _log = _interopRequireDefault(require("./log"));
+var _ecosystem = _interopRequireDefault(require("./ecosystem"));
+var _test = _interopRequireDefault(require("./test"));
+var _database = _interopRequireDefault(require("./database"));
+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/log.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dateFns = require("date-fns");
+var _app = require("../app");
+var _Log = require("../models/Log");
+var _sequelize = _interopRequireDefault(require("./sequelize"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class LogService extends _app.Service {
+  async register(tenantId, data) {
+    try {
+      const Entity = await _sequelize.default.singleton().getModel(_Log.Log, tenantId);
+      await Entity.create({
+        ...data,
+        happenedAt: (0, _dateFns.format)(new Date(), 'yyyy-MM-dd HH:mm:ss')
+      });
+      return true;
+    } catch (error) {
+      new _app.ErrorHandler('Não foi possível registrar um log', error);
+    }
+  }
+}
+var _default = exports.default = LogService;

package/lib/services/rabitmq.js

@@ -0,0 +1,187 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _amqplib = _interopRequireDefault(require("amqplib"));
+var _crypto = require("crypto");
+var _app = require("../app");
+var _service = _interopRequireDefault(require("../app/classes/service"));
+var _messaging = _interopRequireDefault(require("../routes/messaging"));
+var _utils = require("../utils");
+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;
+  mainRouter;
+  eventCustomListeners;
+  exchangeName;
+  queueName;
+  isReconnecting = false; // Flag para evitar múltiplas tentativas simultâneas de reconexão
+  isConnected = false; // Flag para controlar o estado da conexão
+
+  async onServiceClusterInit() {
+    await super.onServiceClusterInit();
+    if (!this.mainRouter) throw new Error('Need router'); //!sem router
+
+    //Start params
+    this.startAttemptDelay = 5 * 1000;
+    this.maxStartAttempts = 3;
+    this.exchangeName = _app.Core.settings.getMessaging().exchanges.main;
+    this.queueName = _app.Core.settings.getAppication().appId;
+    this.eventCustomListeners = new Map();
+    this.mainRouter = {
+      ..._messaging.default,
+      ...this.mainRouter
+    }; // # Register native router
+  }
+  async onStartCluster() {
+    await super.onStartCluster();
+    return this.connect();
+  }
+  async onExodusClusterStarted() {
+    await super.onExodusClusterStarted();
+    await this.channel.consume(this.queueName, this.consumeFromQueue.bind(this), {
+      noAck: false
+    });
+  }
+  async onStartFail() {
+    await super.onStartFail();
+    this.log(`Not possible to connect RabitMQ`, 'danger');
+  }
+  async connect() {
+    if (this.isConnected) return true;
+    if (this.isReconnecting) return false;
+    this.log(`⌛️ Connecting to Rabbit-MQ Server: ${this.currentStartAttempts}/${this.maxStartAttempts}`);
+    this.isReconnecting = true;
+    try {
+      const query = `amqp://${_app.Core.settings.getMessaging().user}:${_app.Core.settings.getMessaging().pass}@${_app.Core.settings.getMessaging().host}:5672`;
+      this.connection = await _amqplib.default.connect(query);
+      this.channel = await this.connection.createChannel();
+      const mainExchanges = _app.Core.settings.getMessaging().exchanges.main;
+      await this.channel.assertExchange(mainExchanges, 'topic', {
+        durable: true
+      });
+      await this.channel.assertQueue(_app.Core.settings.getAppication().appId, {
+        durable: true
+      });
+      this.isConnected = true;
+      this.isReconnecting = false;
+      this.setupErrorHandles();
+      await this.registerHandles();
+      this.log(`✅ Rabbit MQ Connection is ready`);
+      return true;
+    } catch (error) {
+      (0, _utils.logger)().error(error, `Not connected to MQ Server`);
+      this.isReconnecting = false;
+      return false;
+    }
+  }
+  async registerHandles() {
+    for (const topic of Object.keys(this.mainRouter)) {
+      await this.channel.bindQueue(this.queueName, this.exchangeName, topic);
+    }
+  }
+  setupErrorHandles() {
+    this.channel.on('error', err => {
+      new _app.ErrorHandler('falha no canal rabitmq', err);
+      this.isConnected = false;
+    });
+    this.channel.on('close', err => {
+      new _app.ErrorHandler('o canal rabitmq foi fechado', err);
+      this.isConnected = false;
+    });
+  }
+
+  //# Common
+  async sendToQueue(topic, data, transactionId) {
+    try {
+      if (!this.isConnected) {
+        this.log('RabbitMQ is not connected. Message not sent.');
+        return false;
+      }
+      const messageId = (0, _crypto.randomUUID)();
+      const packeg = Buffer.from(JSON.stringify({
+        data,
+        serviceId: _app.Core.settings.getAppication().appId,
+        transactionId
+      }));
+      this.channel.publish(this.exchangeName, topic, packeg, {
+        messageId,
+        persistent: true
+      });
+      return messageId;
+    } catch (error) {
+      new _app.ErrorHandler('Houve um erro no envio de uma mensagem para o rabitmq', error);
+    }
+  }
+  async consumeFromQueue(msg) {
+    if (!this.isConnected) return;
+    if (!msg) {
+      this.log(`Invalid incoming message in`);
+      return;
+    }
+    try {
+      const topic = msg.fields.routingKey;
+      const content = JSON.parse(msg.content.toString());
+      const callBack = this.mainRouter[topic];
+      if (callBack) await callBack(content.data, () => {}, content.serviceId, content.transactionId);
+      this.channel.ack(msg); //# the next function is temporary and not confirm ack
+
+      if (this.eventCustomListeners.has(topic)) {
+        const cb = this.eventCustomListeners.get(topic);
+        cb(content.data, () => {}, content.serviceId, content.transactionId);
+      }
+    } catch (error) {
+      setTimeout(() => {
+        this.channel.nack(msg, false, true); // Reenfileira para nova tentativa
+        this.log(`Message requeue: ${msg.fields.routingKey}`, 'info');
+      }, 3000);
+      new _app.ErrorHandler('Error on parsing message from queue', error);
+    }
+  }
+  static registerRouter(router) {
+    this.getService().mainRouter = router;
+  }
+  onTransaction(topic, callBack) {
+    if (!this.mainRouter[topic]) {
+      this.channel.bindQueue(_app.Core.settings.getAppication().appId, _app.Core.settings.getMessaging().exchanges.main, topic);
+    }
+    this.eventCustomListeners.set(topic, callBack);
+  }
+  offTransaction(topic) {
+    this.eventCustomListeners.delete(topic);
+    if (!this.mainRouter[topic]) {
+      this.channel.unbindQueue(_app.Core.settings.getAppication().appId, _app.Core.settings.getMessaging().exchanges.main, topic);
+    }
+  }
+  asyncRequest(data) {
+    const timeout = data.listen.timeout || 5000;
+    const send = data.send;
+    const listen = data.listen;
+    const sendtransactionId = (0, _crypto.randomUUID)();
+    this.onTransaction(listen.topic, (data, ack, serviceId, transactionId) => {
+      ack(); // !auto ack because rabbit app crash
+      if (sendtransactionId != transactionId) {
+        return;
+      }
+      this.offTransaction(listen.topic);
+      clearTimeout(fnTimeout);
+      listen.callback(data, ack, serviceId, transactionId);
+    });
+    const fnTimeout = setTimeout(() => {
+      this.offTransaction(listen.topic);
+      listen.onTimeout();
+    }, timeout);
+    this.sendToQueue(send.topic, send.data, sendtransactionId);
+  }
+}
+var _default = exports.default = RabbitMQService;

package/lib/services/redis.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _redis = require("redis");
+var _app = require("../app");
+var _service = _interopRequireDefault(require("../app/classes/service"));
+var _cache = require("../app/classes/cache");
+var _utils = require("../utils");
+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;
+  isReconnecting = false; // Flag para evitar múltiplas tentativas simultâneas de reconexão
+  isConnected = false; // Flag para controlar o estado da conexão
+
+  async onServiceInit() {
+    await super.onServiceInit();
+    this.startAttemptDelay = 5 * 1000;
+    this.maxStartAttempts = 3;
+  }
+  async onStart() {
+    await super.onStart();
+    return this.connect();
+  }
+  async onStartFail() {
+    await super.onStartFail();
+    this.log(`Not possible to connect Redis`, 'danger');
+  }
+  async connect() {
+    if (this.isConnected) return true;
+    if (this.isReconnecting) return false;
+    this.log(`⌛️ Connecting to Redis Server: ${this.currentStartAttempts}/${this.maxStartAttempts}`);
+    this.isReconnecting = true;
+    try {
+      const queryConnect = `redis://${_app.Core.settings.getCache().host}:${_app.Core.settings.getCache().port}`;
+      const password = _app.Core.settings.getCache().password;
+      this.client = (0, _redis.createClient)({
+        url: queryConnect,
+        password
+      });
+      await this.client.connect();
+      this.isConnected = true;
+      this.isReconnecting = false;
+      this.setupErrorHandles();
+      this.log(`✅ Redis Connection is ready`);
+      return true;
+    } catch (error) {
+      (0, _utils.logger)().error(error, `Not connected to Redis Server`);
+      this.isReconnecting = false;
+      return false;
+    }
+  }
+  setupErrorHandles() {
+    this.client.on('error', err => {
+      new _app.ErrorHandler('falha na conexão Redis', err);
+      this.isConnected = false;
+    });
+  }
+
+  //* 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);
+  }
+  createCache(key) {
+    return new _cache.RedisCache(this.client, key);
+  }
+}
+var _default = exports.default = RedisService;