exodus-framework 2.0.0

package/build/services/sequelize.js

@@ -0,0 +1,193 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _service = _interopRequireDefault(require("../app/service"));
+var _db = require("../config/db");
+var _Connection = require("@models/Connection");
+var _index = require("@models/index");
+var _database = require("../utils/database");
+var _logger = _interopRequireDefault(require("../utils/logger"));
+var _sequelize = require("sequelize");
+var _error = require("./error");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Serviço de gerênciamento do banco de dados
+ *
+ * @class SequelizeService
+ * @extends {Service}
+ * @implements {IService}
+ */
+class SequelizeService extends _service.default {
+  serviceDB;
+  masterDB;
+  models;
+  connections;
+
+  //# Initialization
+  constructor() {
+    super();
+  }
+  async init() {
+    this.serviceDB = _database.serviceDB;
+    this.masterDB = _database.masterDB;
+    this.models = _index.Models;
+    this.connections = new Map();
+    await this.connectMainDatabase();
+  }
+  async connectMainDatabase() {
+    return new Promise(resolve => {
+      this.masterDB.sync({
+        force: false
+      }).then(() => {
+        this.log('✅ Connected master database sucessfully', 'success');
+        this.serviceDB.sync({
+          force: false
+        }).then(() => {
+          this.log('✅ Connected service database sucessfully', 'success');
+          resolve(true);
+        }).catch(reason => {
+          new _error.ApplicationException('Não foi possível inicializar a conexão com o ServiceDB', reason);
+        });
+      }).catch(reason => {
+        new _error.ApplicationException('Não foi possível inicializar a conexão com MasterDB', reason);
+      });
+    });
+  }
+
+  //# Common
+  reconnect(db, attempts = 2) {
+    db.sync().then(() => {
+      this.log('Database pronto', 'success');
+    }).catch(reason => {
+      this.log('Attemping to connect master database', 'warning');
+      (0, _logger.default)().warn('Erro ao inicializar o banco de dados, tentando novamente...', reason);
+      if (attempts > 0) {
+        setTimeout(() => this.reconnect(db, attempts - 1), 5000);
+      } else {
+        new _error.ApplicationException('Error on connecting master database', reason);
+      }
+    });
+  }
+  getMasterConnection() {
+    return this.masterDB;
+  }
+  async createDB(connection_uuid, name) {
+    const connData = await _Connection.Connection.findByPk(connection_uuid);
+    if (!connData) {
+      this.log('Connection data not found: ' + connection_uuid);
+      return false;
+    }
+    const dbQueryName = `${_db.DatabaseConfig.service.database}_${name}`;
+    const sequelize = new _sequelize.Sequelize({
+      dialect: connData.dialect,
+      username: connData.username,
+      password: connData.password,
+      define: {
+        timestamps: true
+      },
+      timezone: '-03:00',
+      logging(sql, timing) {
+        (0, _logger.default)().trace('DATABASE', sql, timing);
+      }
+    });
+    return new Promise((resolve, reject) => {
+      sequelize.authenticate().then(async () => {
+        const [results] = await sequelize.query(`SHOW DATABASES LIKE '${dbQueryName}';`);
+        if (results.length === 0) {
+          // Se o banco de dados não existir, cria-o
+          await sequelize.query(`CREATE DATABASE ${dbQueryName};`);
+          this.log(`Database "${dbQueryName}" has been created.`);
+          resolve(true);
+        } else {
+          this.log(`Database "${dbQueryName}" already exists.`);
+          resolve(false);
+        }
+      }).catch(reason => {
+        new _error.ApplicationException('Error while checking/creating database:', reason);
+        reject(reason);
+      }).finally(() => {
+        sequelize.close();
+      });
+    });
+  }
+  async deleteDB(connection_uuid, name) {
+    const dbQueryName = `${_db.DatabaseConfig.service.database}_${name}`;
+    const connData = await _Connection.Connection.findByPk(connection_uuid);
+    if (!connData) {
+      this.log('Connection data not found: ' + connection_uuid);
+      return false;
+    }
+    const sequelize = new _sequelize.Sequelize({
+      dialect: connData.dialect,
+      username: connData.username,
+      password: connData.password,
+      define: {
+        timestamps: true
+      },
+      timezone: '-03:00',
+      logging(sql, timing) {
+        (0, _logger.default)().trace('DATABASE', sql, timing);
+      }
+    });
+    return new Promise((resolve, reject) => {
+      sequelize.authenticate().then(async () => {
+        // Se o banco de dados não existir, cria-o
+        await sequelize.query(`DROP DATABASE IF EXISTS ${dbQueryName};`);
+        this.log(`Database "${dbQueryName}" has been deleted.`);
+        resolve(true);
+      }).catch(reason => {
+        new _error.ApplicationException('Error while checking/deleting database:', reason);
+        reject(reason);
+      }).finally(() => {
+        sequelize.close();
+      });
+    });
+  }
+  async getDB(uuid, name) {
+    const dbQueryName = `${_db.DatabaseConfig.service.database}_${name}`;
+    const queryId = `${uuid}@${dbQueryName}`;
+    return this.connections.get(queryId);
+  }
+  async initDB(uuid, name) {
+    const dbQueryName = `${_db.DatabaseConfig.service.database}_${name}`;
+    const queryId = `${uuid}@${dbQueryName}`;
+    if (this.connections.get(queryId)) {
+      return false;
+    }
+    const connData = await _Connection.Connection.findByPk(uuid);
+    if (!connData) {
+      this.log('Connection data not found: ' + uuid);
+      return false;
+    }
+    const conn = new _sequelize.Sequelize({
+      database: dbQueryName,
+      dialect: connData.dialect,
+      username: connData.username,
+      password: connData.password,
+      define: {
+        timestamps: true
+      },
+      timezone: '-03:00',
+      logging(sql, timing) {
+        (0, _logger.default)().trace('DATABASE', sql, timing);
+      }
+    });
+    return new Promise((resolve, reject) => {
+      conn.sync({
+        force: false
+      }).then(() => {
+        this.log(`✅ Connected ${dbQueryName} database sucessfully`, 'success');
+        this.connections.set(queryId, conn);
+        resolve(true);
+      }).catch(reason => {
+        this.log(`error trying to connect: ${dbQueryName}, UUID: ${uuid}`);
+        reject(reason);
+        new _error.ApplicationException(`error trying to connect: ${dbQueryName}, UUID: ${uuid}`, reason);
+      });
+    });
+  }
+}
+var _default = exports.default = SequelizeService;

package/build/services/socket.d.ts

@@ -0,0 +1,18 @@
+import Service from '@app/service';
+import { TSocketEventList } from '../@types';
+import { CorsOptions, CorsOptionsDelegate } from 'cors';
+import { Server as HttpServer } from 'http';
+import { Server } from 'socket.io';
+import { IService } from '../@types/service';
+declare class SocketIOService extends Service implements IService {
+    server: Server;
+    private mainRouter;
+    constructor();
+    init(): Promise<void>;
+    private onConnection;
+    private bindEvents;
+    createSocket(app: HttpServer, cors?: CorsOptions | CorsOptionsDelegate): void;
+    registerRouter(router: TSocketEventList): void;
+}
+export default SocketIOService;
+//# sourceMappingURL=socket.d.ts.map

package/build/services/socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket.d.ts","sourceRoot":"","sources":["../../src/services/socket.ts"],"names":[],"mappings":"AACA,OAAO,OAAO,MAAM,cAAc,CAAC;AACnC,OAAO,EAAgC,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC3E,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,MAAM,CAAC;AACxD,OAAO,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,MAAM,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAW7C,cAAM,eAAgB,SAAQ,OAAQ,YAAW,QAAQ;IAChD,MAAM,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,UAAU,CAAmB;;IAK/B,IAAI;IAQV,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,UAAU;IAQlB,YAAY,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,GAAE,WAAW,GAAG,mBAAqC;IAIvF,cAAc,CAAC,MAAM,EAAE,gBAAgB;CAGxC;AAED,eAAe,eAAe,CAAC"}

package/build/services/socket.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _controller = require("../app/controller");
+var _service = _interopRequireDefault(require("../app/service"));
+var _socket = require("socket.io");
+var _express = _interopRequireDefault(require("./express"));
+var _error = require("./error");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Serviço de gerênciamento de comunicação WS/WSS Socket
+ *
+ * @class SocketIOService
+ * @extends {Service}
+ * @implements {IService}
+ */
+class SocketIOService extends _service.default {
+  server;
+  mainRouter;
+  constructor() {
+    super();
+  }
+  async init() {
+    if (!this.mainRouter) throw new _error.ApplicationException('Need router'); //!sem router
+    const server = _express.default.singleton().getHttpServer();
+    this.createSocket(server);
+    this.server.on('connection', this.onConnection.bind(this));
+    this.log('Socket server created');
+  }
+  onConnection(socket) {
+    this.log(`${socket.id} conectado`);
+    socket.on('disconnect', () => this.log(`${socket.id} desconectado`));
+    this.bindEvents(socket);
+  }
+  bindEvents(socket) {
+    Object.entries(this.mainRouter).forEach(([key, handle]) => {
+      socket.on(key, (...args) => {
+        handle(new _controller.SocketRequest(socket, key), ...args);
+      });
+    });
+  }
+  createSocket(app, cors = {
+    origin: '*'
+  }) {
+    this.server = new _socket.Server(app, {
+      cors
+    });
+  }
+  registerRouter(router) {
+    this.mainRouter = router;
+  }
+}
+var _default = exports.default = SocketIOService;

package/build/services/task.d.ts

@@ -0,0 +1,53 @@
+import Service from '@app/service';
+import Singleton from '@app/singleton';
+import type { Job } from 'bullmq';
+import { Queue, Worker } from 'bullmq';
+import { IService } from '../@types/service';
+declare abstract class TaskServiceBase extends Service implements IService {
+    abstract init(): Promise<void>;
+    abstract registerJob(...args: any[]): Promise<void>;
+}
+export declare class TaskSchedulingService extends TaskServiceBase {
+    private jobsPath;
+    private jobs;
+    init(): Promise<void>;
+    registerJob(job: SchedulingTask): Promise<void>;
+    private importAllJobs;
+    private processAllJobs;
+}
+export declare abstract class SchedulingTask extends Singleton {
+    protected abstract cron: string;
+    protected abstract name: string;
+    protected abstract active: boolean;
+    abstract handler(): Promise<void>;
+    getJobTime(): string;
+    getActive(): boolean;
+    getJobName(): string;
+}
+export declare class TaskQueueService extends TaskServiceBase {
+    private jobsPath;
+    private jobs;
+    private connection;
+    init(): Promise<void>;
+    registerJob(job: QueueTask<any>): Promise<void>;
+    private importAllJobs;
+    private processAllJobs;
+}
+export declare abstract class QueueTask<DataType, ResultType = any, NameType extends string = string> extends Singleton {
+    protected queue: Queue;
+    protected worker: Worker;
+    protected abstract active: boolean;
+    protected abstract queueName: string;
+    initialize(): void;
+    abstract init(): Promise<void>;
+    addJob(data: DataType): Promise<void>;
+    getQueue(): Queue<any, any, string>;
+    setQueue(queue: Queue): void;
+    getWorker(): Worker<any, any, string>;
+    setWorker(worker: Worker): void;
+    getActive(): boolean;
+    getQueueName(): string;
+    abstract handle(_job: Job<DataType, ResultType, NameType>, _token?: string): Promise<ResultType>;
+}
+export {};
+//# sourceMappingURL=task.d.ts.map

package/build/services/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../src/services/task.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,cAAc,CAAC;AACnC,OAAO,SAAS,MAAM,gBAAgB,CAAC;AAEvC,OAAO,KAAK,EAAqB,GAAG,EAAE,MAAM,QAAQ,CAAC;AACrD,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGvC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAK7C,uBAAe,eAAgB,SAAQ,OAAQ,YAAW,QAAQ;IAChE,QAAQ,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAC9B,QAAQ,CAAC,WAAW,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CACpD;AAGD,qBAAa,qBAAsB,SAAQ,eAAe;IACxD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,IAAI,CAAmB;IAEzB,IAAI;IAUG,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;YAG9C,aAAa;YAcb,cAAc;CAO7B;AACD,8BAAsB,cAAe,SAAQ,SAAS;IACpD,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAChC,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAChC,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAEnC,QAAQ,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAE1B,UAAU;IAGV,SAAS;IAGT,UAAU;CAGlB;AAGD,qBAAa,gBAAiB,SAAQ,eAAe;IACnD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,IAAI,CAAmB;IAC/B,OAAO,CAAC,UAAU,CAAoB;IAEhC,IAAI;IAgBG,WAAW,CAAC,GAAG,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;YAI9C,aAAa;YAUb,cAAc;CAmB7B;AACD,8BAAsB,SAAS,CAC7B,QAAQ,EACR,UAAU,GAAG,GAAG,EAChB,QAAQ,SAAS,MAAM,GAAG,MAAM,CAChC,SAAQ,SAAS;IACjB,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC;IACvB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACnC,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE9B,UAAU;IAoBjB,QAAQ,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAEjB,MAAM,CAAC,IAAI,EAAE,QAAQ;IAI3B,QAAQ;IAGR,QAAQ,CAAC,KAAK,EAAE,KAAK;IAGrB,SAAS;IAGT,SAAS,CAAC,MAAM,EAAE,MAAM;IAGxB,SAAS;IAIT,YAAY,IAAI,MAAM;IAG7B,QAAQ,CAAC,MAAM,CAEb,IAAI,EAAE,GAAG,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,CAAC,EAEzC,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,UAAU,CAAC;CACvB"}

package/build/services/task.js

@@ -0,0 +1,160 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TaskSchedulingService = exports.TaskQueueService = exports.SchedulingTask = exports.QueueTask = void 0;
+var _service = _interopRequireDefault(require("../app/service"));
+var _singleton = _interopRequireDefault(require("../app/singleton"));
+var _task = _interopRequireDefault(require("../config/task"));
+var _bullmq = require("bullmq");
+var _fs = require("fs");
+var _nodeSchedule = require("node-schedule");
+var _cache = _interopRequireDefault(require("../config/cache"));
+var _error = require("./error");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//* Base
+class TaskServiceBase extends _service.default {}
+
+//* Scheduler
+class TaskSchedulingService extends TaskServiceBase {
+  jobsPath;
+  jobs;
+  async init() {
+    this.jobsPath = _task.default.schedulerPath;
+    this.jobs = [];
+    this.log('Initializing jobs...', 'info');
+    await this.importAllJobs();
+    await this.processAllJobs();
+    this.log('All jobs initializeds...', 'info');
+  }
+  async registerJob(job) {
+    this.jobs.push(job);
+  }
+  async importAllJobs() {
+    if (!(0, _fs.existsSync)(this.jobsPath)) (0, _fs.mkdirSync)(this.jobsPath, {
+      recursive: true
+    });
+    for (const handlerFile of (0, _fs.readdirSync)(this.jobsPath)) {
+      try {
+        const job = require(`${this.jobsPath}/${handlerFile}`).default;
+        const jobInstance = job.singleton();
+        this.jobs.push(jobInstance);
+      } catch (error) {
+        new _error.ApplicationException(`Falha ao iniciar um ou mais jobs: ${handlerFile}`, error);
+      }
+    }
+  }
+  async processAllJobs() {
+    for (const job of this.jobs) {
+      if (!job.getActive()) continue;
+      (0, _nodeSchedule.scheduleJob)(job.getJobTime(), job.handler.bind(job));
+      this.log(`Job '${job.getJobName()}' started...`, 'warning');
+    }
+  }
+}
+exports.TaskSchedulingService = TaskSchedulingService;
+class SchedulingTask extends _singleton.default {
+  getJobTime() {
+    return this.cron;
+  }
+  getActive() {
+    return this.active;
+  }
+  getJobName() {
+    return this.name;
+  }
+}
+
+//* Queue
+exports.SchedulingTask = SchedulingTask;
+class TaskQueueService extends TaskServiceBase {
+  jobsPath;
+  jobs;
+  connection;
+  async init() {
+    this.jobsPath = _task.default.queuePath;
+    this.jobs = [];
+    this.connection = {
+      host: _cache.default.host,
+      port: Number(_cache.default.port),
+      password: _cache.default.password
+    };
+    this.log('Initializing jobs...', 'info');
+
+    // await this.importAllJobs();
+    await this.processAllJobs();
+    this.log('All jobs initializeds...', 'info');
+  }
+  async registerJob(job) {
+    this.jobs.push(job);
+  }
+  async importAllJobs() {
+    if (!(0, _fs.existsSync)(this.jobsPath)) (0, _fs.mkdirSync)(this.jobsPath, {
+      recursive: true
+    });
+    for (const handlerFile of (0, _fs.readdirSync)(this.jobsPath)) {
+      const job = require(`${this.jobsPath}/${handlerFile}`).default;
+      const jobInstance = job.singleton();
+      this.jobs.push(jobInstance);
+    }
+  }
+  async processAllJobs() {
+    for (const job of this.jobs) {
+      if (!job.getActive()) continue;
+      const queue = new _bullmq.Queue(job.getQueueName(), {
+        connection: this.connection
+      });
+      const worker = new _bullmq.Worker(job.getQueueName(), job.handle.bind(job), {
+        connection: this.connection
+      });
+      job.setQueue(queue);
+      job.setWorker(worker);
+      job.init();
+      this.log(`Job '${job.getQueueName()}' started...`, 'warning');
+    }
+  }
+}
+exports.TaskQueueService = TaskQueueService;
+class QueueTask extends _singleton.default {
+  queue;
+  worker;
+  initialize() {
+    this.queue = new _bullmq.Queue(this.getQueueName(), {
+      // Configurações do Redis
+      connection: {
+        host: 'localhost',
+        port: 6379
+      }
+    });
+    this.worker = new _bullmq.Worker(this.getQueueName(), this.handle.bind(this), {
+      connection: {
+        host: 'localhost',
+        port: 6379
+      }
+    });
+  }
+  async addJob(data) {
+    this.log('adicionando à fila...');
+    await this.queue.add(this.getQueueName(), data);
+  }
+  getQueue() {
+    return this.queue;
+  }
+  setQueue(queue) {
+    this.queue = queue;
+  }
+  getWorker() {
+    return this.worker;
+  }
+  setWorker(worker) {
+    this.worker = worker;
+  }
+  getActive() {
+    return this.active;
+  }
+  getQueueName() {
+    return this.queueName;
+  }
+}
+exports.QueueTask = QueueTask;

package/build/utils/api.d.ts

@@ -0,0 +1,15 @@
+import Core from '@app/core';
+import { AxiosHeaders, AxiosInstance, Method } from 'axios';
+import { IApiResponse } from '../@types/http';
+declare abstract class Api extends Core {
+    axios: AxiosInstance;
+    abstract host: string;
+    abstract headers: Record<string, any>;
+    constructor();
+    init(): Promise<void>;
+    abstract validateStatus(status: number): boolean;
+    request<T>(endpoint: string, method: Method, data?: any, params?: any, headers?: AxiosHeaders): Promise<IApiResponse<T>>;
+    protected getLogicalSecurityId(): string;
+}
+export default Api;
+//# sourceMappingURL=api.d.ts.map

package/build/utils/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/utils/api.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,OAAc,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAEnE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,uBAAe,GAAI,SAAQ,IAAI;IAC7B,KAAK,EAAE,aAAa,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;;IAOhC,IAAI;IAWV,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAE1C,OAAO,CAAC,CAAC,EACb,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,GAAG,EACV,MAAM,CAAC,EAAE,GAAG,EACZ,OAAO,CAAC,EAAE,YAAY;IAgBxB,SAAS,CAAC,oBAAoB;CAI/B;AAED,eAAe,GAAG,CAAC"}

package/build/utils/api.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _core = _interopRequireDefault(require("../app/core"));
+var _error = require("../services/error");
+var _axios = _interopRequireDefault(require("axios"));
+var _dateFns = require("date-fns");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Api extends _core.default {
+  axios;
+  constructor() {
+    super();
+    this.init();
+  }
+  async init() {
+    this.axios = _axios.default.create({
+      baseURL: this.host,
+      headers: {
+        ...this.headers,
+        'Content-Type': 'application/json'
+      },
+      validateStatus: this.validateStatus
+    });
+  }
+  async request(endpoint, method, data, params, headers) {
+    try {
+      const res = await this.axios({
+        method,
+        url: endpoint,
+        data,
+        params,
+        headers: {
+          ...headers,
+          ...this.headers
+        }
+      });
+      return res.data;
+    } catch (error) {
+      new _error.ApplicationException('não foi possível realizar uma requisição', error);
+    }
+  }
+  getLogicalSecurityId() {
+    const date = (0, _dateFns.format)(new Date(), 'yyyy-MM-dd');
+    return String(Date.parse(date) - 5000);
+  }
+}
+var _default = exports.default = Api;

package/build/utils/database.d.ts

@@ -0,0 +1,4 @@
+import { Sequelize } from 'sequelize';
+export declare const serviceDB: Sequelize;
+export declare const masterDB: Sequelize;
+//# sourceMappingURL=database.d.ts.map

package/build/utils/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../src/utils/database.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAGtC,eAAO,MAAM,SAAS,WAYpB,CAAC;AAEH,eAAO,MAAM,QAAQ,WAYnB,CAAC"}

package/build/utils/database.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serviceDB = exports.masterDB = void 0;
+var _db = require("../config/db");
+var _sequelize = require("sequelize");
+var _logger = _interopRequireDefault(require("./logger"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const serviceDB = exports.serviceDB = new _sequelize.Sequelize({
+  database: _db.DatabaseConfig.service.database,
+  dialect: _db.DatabaseConfig.master.dialect,
+  username: _db.DatabaseConfig.master.username,
+  password: _db.DatabaseConfig.master.password,
+  define: {
+    timestamps: true
+  },
+  timezone: '-03:00',
+  logging(sql, timing) {
+    (0, _logger.default)().trace('DATABASE', sql, timing);
+  }
+});
+const masterDB = exports.masterDB = new _sequelize.Sequelize({
+  database: _db.DatabaseConfig.master.database,
+  dialect: _db.DatabaseConfig.master.dialect,
+  username: _db.DatabaseConfig.master.username,
+  password: _db.DatabaseConfig.master.password,
+  define: {
+    timestamps: true
+  },
+  timezone: '-03:00',
+  logging(sql, timing) {
+    (0, _logger.default)().trace('DATABASE', sql, timing);
+  }
+});

package/build/utils/date.d.ts

@@ -0,0 +1,2 @@
+export declare function timestampDifference(timestamp1: number, timestamp2: number, type?: string): number;
+//# sourceMappingURL=date.d.ts.map

package/build/utils/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../src/utils/date.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,SAAM,UAyBrF"}

package/build/utils/date.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.timestampDifference = timestampDifference;
+function timestampDifference(timestamp1, timestamp2, type = 'd') {
+  const difference = timestamp1 - timestamp2;
+  let dvrs;
+  switch (type) {
+    case 'd':
+      dvrs = difference / 1000 / 60 / 60 / 24;
+      break;
+    case 'h':
+      dvrs = difference / 1000 / 60 / 60;
+      break;
+    case 'm':
+      dvrs = difference / 1000 / 60;
+      break;
+    case 's':
+      dvrs = difference / 1000;
+      break;
+    default:
+      dvrs = difference / 1000 / 60 / 60 / 24;
+      break;
+  }
+  return Math.round(dvrs * -1 * 100) / 100;
+}

package/build/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './api';
+export * from './database';
+export * from './date';
+export * from './logger';
+export * from './session';
+//# sourceMappingURL=index.d.ts.map

package/build/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}