exodus-framework 2.0.950 → 2.0.951

package/lib/services/database.d.ts

@@ -0,0 +1,19 @@
+import { Dialect, Model, ModelStatic, Sequelize } from 'sequelize';
+import { Service, ServiceModel } from '../app';
+import { StaticServiceModel } from '../contracts';
+import { EnvDBHost } from '../models';
+declare class DatabaseService extends Service {
+    private entities;
+    private connections;
+    onServiceInit(): Promise<void>;
+    private initConnection;
+    createConnection(host: string, port: number, database: string, username: string, password: string, dialect: Dialect): Promise<Sequelize>;
+    getConnection(tenantId: string): Promise<Sequelize>;
+    getTenantIds(): Promise<string[]>;
+    getTenantInformation(tenantId: string): Promise<EnvDBHost>;
+    private loadEntity;
+    getEntity<M extends ServiceModel<Model>>(model: StaticServiceModel<M>, tenantId: string): Promise<ModelStatic<M>>;
+    private normalizeDatabaseName;
+}
+export default DatabaseService;
+//# sourceMappingURL=database.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../src/services/database.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACnE,OAAO,EAAsB,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAgB,SAAS,EAAE,MAAM,WAAW,CAAC;AAIpD,cAAM,eAAgB,SAAQ,OAAO;IACnC,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,WAAW,CAAyB;IAE/B,aAAa;YAUZ,cAAc;IA0Cf,gBAAgB,CAC3B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO;IAyBL,aAAa,CAAC,QAAQ,EAAE,MAAM;IAQ9B,YAAY;IAKZ,oBAAoB,CAAC,QAAQ,EAAE,MAAM;YAMpC,UAAU;IASX,SAAS,CAAC,CAAC,SAAS,YAAY,CAAC,KAAK,CAAC,EAClD,KAAK,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC5B,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAU1B,OAAO,CAAC,qBAAqB;CAG9B;AAED,eAAe,eAAe,CAAC"}

package/lib/services/database.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _sequelize = require("sequelize");
+var _app = require("../app");
+var _models = require("../models");
+var _utils = require("../utils");
+var _security = _interopRequireDefault(require("./security"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class DatabaseService extends _app.Service {
+  entities;
+  connections;
+  async onServiceInit() {
+    this.entities = new Map();
+    this.connections = new Map();
+
+    // para busca rápidas
+    this.connections.set(_app.Core.settings.getDatabase().service.database, _utils.serviceDB);
+    this.connections.set(_app.Core.settings.getDatabase().master.database, _utils.masterDB);
+  }
+
+  //* Connection
+  async initConnection(tenantId) {
+    const tenantInfo = await this.getTenantInformation(tenantId);
+    if (!tenantInfo) {
+      throw new Error(`Não é possível inicia a conexão para o tenant ${tenantId}, a relação EnvDB não foi localizada`);
+    }
+    const dbHost = await _models.DatabaseHost.findByPk(tenantInfo.hostUuid);
+    if (!tenantInfo) {
+      throw new Error(`Não é possível inicia a conexão para o tenant ${tenantId}, não foi possível localizar a informação de host`);
+    }
+    const splitedInfo = dbHost.host.split(':');
+    const address = splitedInfo[0];
+    const port = Number(splitedInfo[1]);
+    const database = this.normalizeDatabaseName(tenantInfo.envToken);
+    const key = await _security.default.getService().loadKeyByStr(dbHost.credential);
+    const data = await _security.default.getService().verifySignature(dbHost.password, key);
+    if (!data) {
+      throw new Error(`Não foi possível descriptografar as credenciais de conexão para hostUuid: ${tenantInfo.hostUuid}`);
+    }
+    const password = data.payload;
+    const connection = await this.createConnection(address, port, database, dbHost.username, password, dbHost.dialect);
+    this.connections.set(tenantId, connection);
+  }
+  async createConnection(host, port, database, username, password, dialect) {
+    const sequelize = new _sequelize.Sequelize({
+      host,
+      port,
+      dialect,
+      database,
+      username,
+      password,
+      define: {
+        timestamps: true
+      },
+      timezone: '-03:00',
+      logging: _app.Core.settings.getDatabase().service.log
+    });
+    try {
+      await sequelize.authenticate();
+      return sequelize;
+    } catch (error) {
+      new _app.ErrorHandler('Não foi possível realizar uma conexão', error);
+      return null;
+    }
+  }
+  async getConnection(tenantId) {
+    if (!this.connections.has(tenantId)) {
+      await this.initConnection(tenantId);
+    }
+    return this.connections.get(tenantId);
+  }
+
+  //* Environment
+  async getTenantIds() {
+    const tenants = await _models.EnvDBHost.findAll({
+      attributes: ['envUuid']
+    });
+    return tenants.map(t => t.envUuid);
+  }
+  async getTenantInformation(tenantId) {
+    const relation = await _models.EnvDBHost.findOne({
+      where: {
+        envUuid: tenantId
+      }
+    });
+    return relation;
+  }
+
+  //* Entity
+  async loadEntity(entity, tenantId) {
+    const k = `${tenantId}#${entity.name}`;
+    const connection = await this.getConnection(tenantId);
+    const loadedEntity = entity.initialize(connection);
+    await loadedEntity.sync();
+    this.entities.set(k, loadedEntity);
+  }
+  async getEntity(model, tenantId) {
+    const k = `${tenantId}#${model.name}`;
+    if (!this.entities.has(k)) {
+      await this.loadEntity(model, tenantId);
+    }
+    return this.entities.get(k);
+  }
+
+  //* Utils
+  normalizeDatabaseName(envToken) {
+    return `${_app.Core.settings.getDatabase().service.database}_${envToken}`;
+  }
+}
+var _default = exports.default = DatabaseService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exodus-framework",
-  "version": "2.0.950",
+  "version": "2.0.951",
   "description": "Exodus Framework",
   "author": "jhownpaixao",
   "license": "ISC",