exodus-framework 2.0.723 → 2.0.725

package/lib/services/sequelize.d.ts

@@ -11,23 +11,20 @@ declare class SequelizeService extends Service implements IService {
     relations: Map<string, EnvDBHost>;
     constructor();
     init(): Promise<void>;
-    connectMainDatabase(): Promise<unknown>;
-    reconnect(db: Sequelize, attempts?: number): void;
-    getMasterConnection(): Sequelize;
+    connectDatabases(): Promise<unknown>;
+    getDB(tenantId: string): Promise<false | Sequelize>;
     createDB(hostUuid: string, name: string): Promise<boolean>;
     deleteDB(hostUuid: string, name: string): Promise<boolean>;
-    getDatabaseConnection(tenantId: string): Promise<false | Sequelize>;
-    testHostConnections(host: string, port: number, username: string, password: string): Promise<boolean>;
-    initDatabase(tenantId: string): Promise<false | Sequelize>;
-    registerModels(models: ModelStatic<any>[]): void;
+    initDB(tenantId: string): Promise<false | Sequelize>;
+    getDBName(envToken: string): string;
+    reconnect(db: Sequelize, attempts?: number): void;
+    createConnection(hostUuid: string, database?: string): Promise<false | Sequelize>;
+    testConnection(host: string, port: number, username: string, password: string): Promise<boolean>;
+    getRelation(tenantId: string): Promise<EnvDBHost>;
     getModel<M extends typeof Model<any, any>>(model: typeof Model<any, any> & {
         initialize: (connection: Sequelize) => M;
     }, tenantId: string): Promise<M>;
-    parseDataInfoByTenantId(tenant: string): {
-        envToken: string;
-        con_uuid: string;
-    };
-    getDatabaseNamePattern(envToken: string): string;
+    registerModels(models: ModelStatic<any>[]): void;
 }
 export default SequelizeService;
 //# sourceMappingURL=sequelize.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sequelize.d.ts","sourceRoot":"","sources":["../../src/services/sequelize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE1D,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAgB,MAAM,WAAW,CAAC;AAcpD,cAAM,gBAAiB,SAAQ,OAAQ,YAAW,QAAQ;IACxD,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC;IAC3B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACpC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IACvD,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;;IAM5B,IAAI;IAOJ,mBAAmB;IAgCzB,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,QAAQ,SAAI;IAerC,mBAAmB;IAGb,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IA6CvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IA0CvC,qBAAqB,CAAC,QAAQ,EAAE,MAAM;IA4BtC,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IA0BlF,YAAY,CAAC,QAAQ,EAAE,MAAM;IAsDnC,cAAc,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE;IAInC,QAAQ,CAAC,CAAC,SAAS,OAAO,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAC7C,KAAK,EAAE,OAAO,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG;QAAE,UAAU,EAAE,CAAC,UAAU,EAAE,SAAS,KAAK,CAAC,CAAA;KAAE,EAC5E,QAAQ,EAAE,MAAM;IAwBlB,uBAAuB,CAAC,MAAM,EAAE,MAAM;;;;IAOtC,sBAAsB,CAAC,QAAQ,EAAE,MAAM;CAGxC;AAED,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"sequelize.d.ts","sourceRoot":"","sources":["../../src/services/sequelize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE1D,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAgB,MAAM,WAAW,CAAC;AAcpD,cAAM,gBAAiB,SAAQ,OAAQ,YAAW,QAAQ;IACxD,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC;IAC3B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACpC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IACvD,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;;IAM5B,IAAI;IAOJ,gBAAgB;IAgChB,KAAK,CAAC,QAAQ,EAAE,MAAM;IActB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IA6BvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAiBvC,MAAM,CAAC,QAAQ,EAAE,MAAM;IAiB7B,SAAS,CAAC,QAAQ,EAAE,MAAM;IAK1B,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,QAAQ,SAAI;IAe/B,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IA6CpD,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IA4B7E,WAAW,CAAC,QAAQ,EAAE,MAAM;IAe5B,QAAQ,CAAC,CAAC,SAAS,OAAO,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAC7C,KAAK,EAAE,OAAO,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG;QAAE,UAAU,EAAE,CAAC,UAAU,EAAE,SAAS,KAAK,CAAC,CAAA;KAAE,EAC5E,QAAQ,EAAE,MAAM;IAsBlB,cAAc,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE;CAG1C;AAED,eAAe,gBAAgB,CAAC"}

package/lib/services/sequelize.js

@@ -38,9 +38,9 @@ class SequelizeService extends _service.default {
     this.masterDB = _database.masterDB;
     this.connections = new Map();
     this.initializedModels = new Map();
-    await this.connectMainDatabase();
+    await this.connectDatabases();
   }
-  async connectMainDatabase() {
+  async connectDatabases() {
     if (!this.models) throw new _error.ApplicationException('Models are requireds! Call registerModels(modelsArray)');
 
     // #Include native models
@@ -64,22 +64,18 @@ class SequelizeService extends _service.default {
     });
   }
 
-  //# 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;
+  // #Database
+  async getDB(tenantId) {
+    /* master or service */
+    if (tenantId == _app.Core.settings.getDatabase().service.database) {
+      return _database.serviceDB;
+    } else if (tenantId == _app.Core.settings.getDatabase().master.database) {
+      return _database.masterDB;
+    }
+    const relation = await this.getRelation(tenantId);
+    if (!relation) return false;
+    const key = `${relation.hostUuid}@${this.getDBName(relation.envToken)}`;
+    return this.connections.get(key) || (await this.initDB(tenantId));
   }
   async createDB(hostUuid, name) {
     const host = await _DatabaseHost.DatabaseHost.findByPk(hostUuid);
@@ -88,52 +84,95 @@ class SequelizeService extends _service.default {
       return false;
     }
     const dbQueryName = `${_app.Core.settings.getDatabase().service.database}_${name}`;
-    const sequelize = new _sequelize.Sequelize({
-      dialect: host.dialect,
-      username: host.username,
-      password: host.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}';`);
+    const connection = await this.createConnection(hostUuid);
+    if (connection) {
+      try {
+        const [results] = await connection.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};`);
+          await connection.query(`CREATE DATABASE ${dbQueryName};`);
           this.log(`Database "${dbQueryName}" has been created.`);
-          resolve(true);
+          return true;
         } else {
           this.log(`Database "${dbQueryName}" already exists.`);
-          resolve(false);
+          return false;
         }
-      }).catch(reason => {
-        new _error.ApplicationException('Error while checking/creating database:', reason);
-        reject(reason);
-      }).finally(() => {
-        sequelize.close();
-      });
-    });
+      } catch (error) {
+        new _error.ApplicationException('Erro on creating database', error);
+      } finally {
+        connection.close();
+      }
+    }
+    return false;
   }
   async deleteDB(hostUuid, name) {
     const dbQueryName = `${_app.Core.settings.getDatabase().service.database}_${name}`;
+    const connection = await this.createConnection(hostUuid);
+    if (connection) {
+      try {
+        await connection.query(`DROP DATABASE IF EXISTS ${dbQueryName};`);
+        this.log(`Database "${dbQueryName}" has been deleted.`);
+        return true;
+      } catch (error) {
+        return false;
+      } finally {
+        connection.close();
+      }
+    }
+    return false;
+  }
+  async initDB(tenantId) {
+    const relation = await this.getRelation(tenantId);
+    if (!relation) return false;
+    const dbName = this.getDBName(relation.envToken);
+    const key = `${relation.hostUuid}@${this.getDBName(relation.envToken)}`;
+    if (this.connections.has(key)) return this.connections.get(key);
+    const connection = await this.createConnection(relation.hostUuid, dbName);
+    if (connection) {
+      this.log(`✅ Connected ${dbName} database sucessfully`, 'success');
+      this.connections.set(key, connection);
+      return connection;
+    }
+  }
+  getDBName(envToken) {
+    return `${_app.Core.settings.getDatabase().service.database}_${envToken}`;
+  }
+
+  //#Connection
+  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);
+      }
+    });
+  }
+  async createConnection(hostUuid, database) {
     const host = await _DatabaseHost.DatabaseHost.findByPk(hostUuid);
     if (!host) {
-      this.log('Database host information not found: ' + hostUuid);
+      this.log('createConnection:: Database host information not found: ' + hostUuid);
       return false;
     }
+    const key = await _security.default.singleton().loadKeyByStr(host.credential);
+    const data = await _security.default.singleton().verifySignature(host.password, key);
+    if (!data) {
+      this.log('createConnection::Error on decript password by credential: ' + hostUuid, 'danger');
+      return false;
+    }
+    const password = data.payload;
     const queryHost = host.host.split(':');
     const sequelize = new _sequelize.Sequelize({
       host: queryHost[0],
       port: Number(queryHost[1]),
       dialect: host.dialect,
+      database,
       username: host.username,
-      password: host.password,
+      password: password,
       define: {
         timestamps: true
       },
@@ -144,47 +183,13 @@ class SequelizeService extends _service.default {
     });
     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);
+        resolve(sequelize);
       }).catch(reason => {
-        new _error.ApplicationException('Error while checking/deleting database:', reason);
         reject(reason);
-      }).finally(() => {
-        sequelize.close();
       });
     });
   }
-  async getDatabaseConnection(tenantId) {
-    let relation;
-
-    /* master or service */
-    if (tenantId == _app.Core.settings.getDatabase().service.database) {
-      return _database.serviceDB;
-    } else if (tenantId == _app.Core.settings.getDatabase().master.database) {
-      return _database.masterDB;
-    }
-
-    /* fetch relation */
-    if (this.relations.get(tenantId)) {
-      relation = this.relations.get(tenantId);
-    } else {
-      relation = await _models.EnvDBHost.findOne({
-        where: {
-          envUuid: tenantId
-        }
-      });
-      if (!relation) {
-        new _error.ApplicationException('Não foi possível encontrar a relação env-db: tenantId=' + tenantId);
-        return false;
-      }
-      this.relations.set(tenantId, relation);
-    }
-    const queryId = `${relation.hostUuid}@${this.getDatabaseNamePattern(relation.envToken)}`;
-    return this.connections.get(queryId) || (await this.initDatabase(tenantId));
-  }
-  async testHostConnections(host, port, username, password) {
+  async testConnection(host, port, username, password) {
     const sequelize = new _sequelize.Sequelize({
       host,
       port,
@@ -199,95 +204,53 @@ class SequelizeService extends _service.default {
       sequelize.authenticate().then(async () => {
         resolve(true);
       }).catch(reason => {
+        new _error.ApplicationException('teste de conexão falhou', reason);
         resolve(false);
       }).finally(() => {
         sequelize.close();
       });
     });
   }
-  async initDatabase(tenantId) {
-    const {
-      con_uuid: hostUuid,
-      envToken
-    } = this.parseDataInfoByTenantId(tenantId);
-    const dbName = `${_app.Core.settings.getDatabase().service.database}_${envToken}`; //nomeclatura padrão do banco de dados do serviço
-    const queryId = `${dbName}@${hostUuid}`;
-    if (this.connections.get(queryId)) {
-      return this.connections.get(queryId);
-    }
-    const host = await _DatabaseHost.DatabaseHost.findByPk(hostUuid);
-    if (!host) {
-      this.log('Error on init connection, data not found! uuid: ' + hostUuid, 'danger');
-      return false;
-    }
-    const key = await _security.default.singleton().loadKeyByStr(host.credential);
-    const data = await _security.default.singleton().verifySignature(host.password, key);
-    if (!data) {
-      this.log('Error on decript password by credential: ' + hostUuid, 'danger');
-      return false;
-    }
-    const password = data.payload;
-    const conn = new _sequelize.Sequelize({
-      host: host.host,
-      database: dbName,
-      dialect: host.dialect,
-      username: host.username,
-      password: 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 ${dbName} database sucessfully`, 'success');
-        this.connections.set(queryId, conn);
-        resolve(conn);
-      }).catch(reason => {
-        this.log(`error trying to connect: ${dbName}, UUID: ${hostUuid}`);
-        reject(reason);
-        new _error.ApplicationException(`error trying to connect: ${dbName}, UUID: ${hostUuid}`, reason);
+
+  //# Common
+  async getRelation(tenantId) {
+    let relation;
+    /* fetch relation */
+    if (this.relations.get(tenantId)) {
+      relation = this.relations.get(tenantId);
+    } else {
+      relation = await _models.EnvDBHost.findOne({
+        where: {
+          envUuid: tenantId
+        }
       });
-    });
-  }
-  registerModels(models) {
-    this.models = models;
+      if (relation) {
+        this.relations.set(tenantId, relation);
+      }
+    }
+    return relation;
   }
+
+  // #Entity
   async getModel(model, tenantId) {
-    const {
-      con_uuid,
-      envToken
-    } = this.parseDataInfoByTenantId(tenantId);
-    const modelInitID = `${envToken}@${con_uuid}#${model.name}`;
-    const cache = this.initializedModels.get(modelInitID);
-    if (cache) {
-      return cache;
-    }
-    const connection = await this.getDatabaseConnection(tenantId);
-    if (!connection) {
-      throw new _error.ApplicationException('Não foi possível obter o model espeficificado: Conexão não encontrada');
+    try {
+      const relation = await this.getRelation(tenantId);
+      const modelKey = `${relation.envToken}@${relation.hostUuid}#${model.name}`;
+      if (this.initializedModels.has(modelKey)) return this.initializedModels.get(modelKey);
+      const connection = await this.getDB(tenantId);
+      if (!connection) {
+        throw new _error.ApplicationException('Conexão não encontrada');
+      }
+      const m = model.initialize(connection);
+      await m.sync();
+      this.initializedModels.set(modelKey, m);
+      return m;
+    } catch (error) {
+      throw new _error.ApplicationException('Erro ao obter o model', error);
     }
-    const m = model.initialize(connection);
-    await m.sync();
-    this.initializedModels.set(modelInitID, m);
-    return m;
   }
-  parseDataInfoByTenantId(tenant) {
-    const e = tenant.split('@');
-    const envToken = e[0];
-    const con_uuid = e[1];
-    return {
-      envToken,
-      con_uuid
-    };
-  }
-  getDatabaseNamePattern(envToken) {
-    return `${_app.Core.settings.getDatabase().service.database}_${envToken}`;
+  registerModels(models) {
+    this.models = models;
   }
 }
 var _default = exports.default = SequelizeService;

package/package.json

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