exodus-framework 2.0.955 → 2.0.956

package/lib/middlewares/access.js

@@ -0,0 +1,114 @@
+"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 {
+  /**
+   * !Deve ser chamada!!
+   *
+   * @param {TAccountType[]} level
+   * @memberof AccessMiddleware
+   */
+  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 isApplication = false;
+
+    //! Negar caso não haja um ou outro;
+    if (!account && !applicationId && !tenantId) {
+      throw new _app.HttpError({
+        message: 'Credênciais de autênticação não informadas',
+        statusCode: _http.EHttpResponseCode.informationUnauthorized
+      });
+    }
+    const requestor = {
+      database: '',
+      id: account?.uuid,
+      name: account?.name,
+      environmentId: tenantId,
+      trigger: tenantId
+    };
+    let envUuid = '';
+
+    /* Aplicações */
+    if (applicationId) {
+      isApplication = true;
+      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
+          });
+        }
+        requestor.database = data.payload.database;
+        requestor.environmentId = data.payload.envUuid;
+        requestor.name = application.dataValues.name;
+        requestor.id = data.payload.token;
+        requestor.trigger = applicationId;
+        envUuid = data.payload.envUuid;
+      }
+    } else if (tenantId) {
+      if (!account) {
+        throw new _app.HttpError({
+          message: 'Não é permitido o uso do tenantId sem uma sessão ativa',
+          statusCode: _http.EHttpResponseCode.informationBlocked
+        });
+      }
+      envUuid = tenantId;
+      if (account.type != 'ADMINISTRATOR') {
+        requestor.environmentId = account.envUuid;
+        envUuid = account.envUuid;
+      }
+    }
+    req.tenant = {
+      id: envUuid || _app.Core.settings.getDatabase().main.database
+    };
+    req.requestor = requestor;
+    req.isApplication = isApplication;
+    next();
+  };
+}
+var _default = exports.default = AccessMiddleware;

package/lib/middlewares/authentication.js

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SocketAuthenticationMiddleware = exports.AuthenticationMiddleware = void 0;
+var _dateFns = require("date-fns");
+var _expressJwt = require("express-jwt");
+var _app = require("../app");
+var _controller = _interopRequireWildcard(require("../app/controller"));
+var _models = require("../models");
+var _security = _interopRequireDefault(require("../services/security"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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; }
+class AuthenticationMiddleware extends _controller.default {
+  decryptToken(required = true) {
+    return (0, _expressJwt.expressjwt)({
+      secret: async () => {
+        return _security.default.singleton().getServicePublicKey().toPEM(false);
+      },
+      issuer: _app.Core.settings.getAuthentication().serviceIssuer,
+      algorithms: ['RS256'],
+      credentialsRequired: required // Controla se o token é obrigatório
+    });
+  }
+}
+exports.AuthenticationMiddleware = AuthenticationMiddleware;
+class SocketAuthenticationMiddleware extends _controller.SocketController {
+  decryptToken = async (socket, next) => {
+    const token = socket.handshake.auth['bearer'] ? socket.handshake.auth['bearer'].replace('Bearer ', '') : '';
+    const tenantId = socket.handshake.auth['X-Exodus-Tenant-ID'];
+    const applicationId = socket.handshake.auth['X-Exodus-Application-ID'];
+    let isApplication = false;
+    let envUuid = '';
+    try {
+      if (!token) {
+        return next(new Error('Token ausente'));
+      }
+      const data = await _security.default.getService().verifySignature(token, _security.default.singleton().getServicePublicKey());
+      if (!data) {
+        return next(new Error('Token inválido'));
+      }
+      const account = data['account'];
+      socket.auth = {
+        account: account,
+        exp: data.exp || 0,
+        iat: 0,
+        iss: data.iss || ''
+      };
+      const requestor = {
+        database: '',
+        id: account.uuid,
+        name: account.name,
+        environmentId: tenantId,
+        trigger: tenantId
+      };
+
+      /* Aplicações */
+      if (applicationId) {
+        isApplication = true;
+        const application = await _models.Application.findOne({
+          where: {
+            token: applicationId
+          }
+        });
+        if (!application) {
+          return next(new Error('Token de aplicação inválido'));
+        } else if (!application.active) {
+          return next(new Error('Token de aplicação desativado'));
+        } else if ((0, _dateFns.isBefore)(application.expiresAt, new Date())) {
+          return next(new Error('Token de aplicação expirado'));
+        } else {
+          //valido
+          const data = await _security.default.singleton().verifySignature(applicationId, _security.default.singleton().getServicePublicKey());
+          if (!data) {
+            return next(new Error('Token de aplicação sem autênticidade'));
+          }
+          requestor.database = data.payload.database;
+          requestor.environmentId = data.payload.envUuid;
+          requestor.name = application.dataValues.name;
+          requestor.id = data.payload.token;
+          requestor.trigger = applicationId;
+          envUuid = data.payload.envUuid;
+        }
+      } else if (tenantId) {
+        envUuid = tenantId;
+      }
+      if (account && account.type != 'ADMINISTRATOR') {
+        requestor.environmentId = account.envUuid;
+        envUuid = account.envUuid;
+      }
+      socket.tenant = {
+        id: envUuid || _app.Core.settings.getDatabase().main.database
+      };
+      socket.requestor = requestor;
+      socket.isApplication = isApplication;
+      next();
+    } catch (error) {
+      return next(error);
+    }
+  };
+}
+exports.SocketAuthenticationMiddleware = SocketAuthenticationMiddleware;

package/lib/middlewares/file.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _controller = _interopRequireDefault(require("../app/controller"));
+var _multer = _interopRequireDefault(require("multer"));
+var fs = _interopRequireWildcard(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+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 FileMiddleware extends _controller.default {
+  storage;
+  constructor() {
+    super();
+    this.initStorage();
+  }
+  initStorage() {
+    this.storage = _multer.default.diskStorage({
+      destination: async (req, file, cb) => {
+        !fs.existsSync(_app.Core.settings.getAppication().filePaths.temporary) && fs.mkdirSync(_app.Core.settings.getAppication().filePaths.temporary, {
+          recursive: true
+        });
+        cb(null, _app.Core.settings.getAppication().filePaths.temporary);
+      },
+      filename: (req, file, cb) => {
+        const name = Date.now() + _path.default.extname(file.originalname);
+        cb(null, name);
+      }
+    });
+  }
+  upload = field => {
+    return (0, _multer.default)({
+      storage: this.storage
+    }).single(field);
+  };
+}
+var _default = exports.default = FileMiddleware;

package/lib/middlewares/index.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  AccessMiddleware: true,
+  FileMiddleware: true
+};
+Object.defineProperty(exports, "AccessMiddleware", {
+  enumerable: true,
+  get: function () {
+    return _access.default;
+  }
+});
+Object.defineProperty(exports, "FileMiddleware", {
+  enumerable: true,
+  get: function () {
+    return _file.default;
+  }
+});
+var _access = _interopRequireDefault(require("./access"));
+var _authentication = require("./authentication");
+Object.keys(_authentication).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _authentication[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _authentication[key];
+    }
+  });
+});
+var _file = _interopRequireDefault(require("./file"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/models/Application.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Application = void 0;
+var _sequelize = require("sequelize");
+var _database = require("../utils/database");
+class Application extends _sequelize.Model {}
+exports.Application = Application;
+Application.init({
+  uuid: {
+    type: _sequelize.DataTypes.UUID,
+    defaultValue: _sequelize.DataTypes.UUIDV4,
+    primaryKey: true,
+    allowNull: false,
+    autoIncrement: false
+  },
+  name: {
+    type: _sequelize.DataTypes.STRING(200),
+    allowNull: false
+  },
+  token: {
+    type: _sequelize.DataTypes.TEXT,
+    allowNull: false
+  },
+  key: {
+    type: _sequelize.DataTypes.TEXT,
+    allowNull: false
+  },
+  envUuid: {
+    type: _sequelize.DataTypes.UUID,
+    allowNull: false
+  },
+  acess: {
+    type: _sequelize.DataTypes.JSON(),
+    allowNull: true
+  },
+  expiresAt: {
+    type: _sequelize.DataTypes.DATE,
+    allowNull: false
+  },
+  active: {
+    type: _sequelize.DataTypes.BOOLEAN,
+    defaultValue: true
+  },
+  comments: {
+    type: _sequelize.DataTypes.STRING(255),
+    allowNull: true
+  },
+  params: {
+    type: _sequelize.DataTypes.JSON,
+    defaultValue: {},
+    allowNull: true
+  }
+}, {
+  tableName: 'applications',
+  sequelize: _database.mainDb,
+  indexes: [{
+    fields: ['name']
+  }, {
+    fields: ['token'],
+    unique: true
+  }]
+});

package/lib/models/DatabaseHost.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DatabaseHost = void 0;
+var _sequelize = require("sequelize");
+var _database = require("../utils/database");
+class DatabaseHost extends _sequelize.Model {}
+exports.DatabaseHost = DatabaseHost;
+DatabaseHost.init({
+  uuid: {
+    type: _sequelize.DataTypes.UUID,
+    defaultValue: _sequelize.DataTypes.UUIDV4,
+    primaryKey: true,
+    allowNull: false,
+    autoIncrement: false
+  },
+  host: {
+    type: _sequelize.DataTypes.STRING(200),
+    allowNull: false
+  },
+  name: {
+    type: _sequelize.DataTypes.STRING(200),
+    allowNull: false
+  },
+  dialect: {
+    type: _sequelize.DataTypes.ENUM('mysql', 'postgres', 'sqlite', 'mariadb', 'mssql', 'db2', 'snowflake', 'oracle'),
+    allowNull: false
+  },
+  username: {
+    type: _sequelize.DataTypes.STRING(100),
+    allowNull: false
+  },
+  credential: {
+    type: _sequelize.DataTypes.TEXT,
+    allowNull: false
+  },
+  password: {
+    type: _sequelize.DataTypes.TEXT,
+    allowNull: false
+  },
+  active: {
+    type: _sequelize.DataTypes.BOOLEAN,
+    defaultValue: true
+  },
+  params: {
+    type: _sequelize.DataTypes.JSON,
+    defaultValue: {},
+    allowNull: true
+  }
+}, {
+  tableName: 'database_hosts',
+  sequelize: _database.mainDb,
+  indexes: [{
+    fields: ['name'],
+    unique: true
+  }, {
+    fields: ['host'],
+    unique: true
+  }]
+});

package/lib/models/EnvConnection.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EnvDBHost = void 0;
+var _sequelize = require("sequelize");
+var _database = require("../utils/database");
+class EnvDBHost extends _sequelize.Model {}
+exports.EnvDBHost = EnvDBHost;
+EnvDBHost.init({
+  uuid: {
+    type: _sequelize.DataTypes.UUID,
+    defaultValue: _sequelize.DataTypes.UUIDV4,
+    primaryKey: true,
+    allowNull: false,
+    autoIncrement: false
+  },
+  hostUuid: {
+    type: _sequelize.DataTypes.UUID,
+    allowNull: false
+  },
+  envUuid: {
+    type: _sequelize.DataTypes.UUID,
+    allowNull: false
+  },
+  envToken: {
+    type: _sequelize.DataTypes.UUID,
+    allowNull: false
+  }
+}, {
+  tableName: 'env_dbhost',
+  sequelize: _database.mainDb,
+  indexes: [{
+    fields: ['envUuid'],
+    unique: true
+  }, {
+    fields: ['envToken', 'hostUuid'],
+    unique: true
+  }]
+});

package/lib/models/Log.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Log = void 0;
+var _sequelize = require("sequelize");
+var _database = require("../utils/database");
+var _servicemodel = _interopRequireDefault(require("../app/classes/servicemodel"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Log extends _servicemodel.default {
+  static getConnParams() {
+    return {
+      tableName: 'logs',
+      sequelize: _database.mainDb,
+      indexes: [{
+        fields: ['category']
+      }, {
+        fields: ['origin']
+      }, {
+        fields: ['action']
+      }]
+    };
+  }
+  static getEntityParams() {
+    return {
+      uuid: {
+        type: _sequelize.DataTypes.UUID,
+        defaultValue: _sequelize.DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+        autoIncrement: false
+      },
+      happenedAt: {
+        type: _sequelize.DataTypes.DATE,
+        allowNull: false
+      },
+      category: {
+        type: _sequelize.DataTypes.STRING(100),
+        allowNull: false
+      },
+      origin: {
+        type: _sequelize.DataTypes.STRING(100),
+        allowNull: false
+      },
+      action: {
+        type: _sequelize.DataTypes.STRING(100),
+        allowNull: false
+      },
+      comments: {
+        type: _sequelize.DataTypes.STRING(255),
+        allowNull: true
+      },
+      data: {
+        type: _sequelize.DataTypes.JSON,
+        defaultValue: {},
+        allowNull: true
+      },
+      params: {
+        type: _sequelize.DataTypes.JSON,
+        defaultValue: {},
+        allowNull: true
+      }
+    };
+  }
+}
+exports.Log = Log;

package/lib/models/Report.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Report = void 0;
+var _sequelize = require("sequelize");
+var _servicemodel = _interopRequireDefault(require("../app/classes/servicemodel"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Report extends _servicemodel.default {
+  static getConnParams() {
+    return {
+      tableName: 'reports',
+      indexes: [{
+        fields: ['category']
+      }, {
+        fields: ['description']
+      }, {
+        fields: ['file']
+      }]
+    };
+  }
+  static getEntityParams() {
+    return {
+      uuid: {
+        type: _sequelize.DataTypes.UUID,
+        defaultValue: _sequelize.DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+        autoIncrement: false
+      },
+      category: {
+        type: _sequelize.DataTypes.STRING(100),
+        allowNull: false
+      },
+      origin: {
+        type: _sequelize.DataTypes.STRING(100),
+        allowNull: false
+      },
+      description: {
+        type: _sequelize.DataTypes.STRING(255),
+        allowNull: true
+      },
+      file: {
+        type: _sequelize.DataTypes.STRING(255),
+        allowNull: true
+      },
+      total: {
+        type: _sequelize.DataTypes.INTEGER(),
+        allowNull: true
+      },
+      params: {
+        type: _sequelize.DataTypes.JSON,
+        defaultValue: {},
+        allowNull: true
+      },
+      status: {
+        type: _sequelize.DataTypes.ENUM('PENDING', 'COMPLETED'),
+        allowNull: false,
+        defaultValue: 'PENDING'
+      }
+    };
+  }
+}
+exports.Report = Report;

package/lib/models/System.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.System = void 0;
+var _sequelize = require("sequelize");
+var _database = require("../utils/database");
+var _servicemodel = _interopRequireDefault(require("../app/classes/servicemodel"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class System extends _servicemodel.default {
+  static getConnParams() {
+    return {
+      tableName: 'system',
+      sequelize: _database.mainDb,
+      indexes: [{
+        fields: ['key']
+      }, {
+        fields: ['value']
+      }, {
+        fields: ['comments']
+      }]
+    };
+  }
+  static getEntityParams() {
+    return {
+      uuid: {
+        type: _sequelize.DataTypes.UUID,
+        defaultValue: _sequelize.DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+        autoIncrement: false
+      },
+      key: {
+        type: _sequelize.DataTypes.STRING(100),
+        allowNull: false
+      },
+      value: {
+        type: _sequelize.DataTypes.STRING(255),
+        allowNull: false
+      },
+      comments: {
+        type: _sequelize.DataTypes.STRING(255),
+        allowNull: true
+      },
+      data: {
+        type: _sequelize.DataTypes.JSON,
+        defaultValue: {},
+        allowNull: true
+      }
+    };
+  }
+}
+exports.System = System;